plugins/dali-sharp/dali-bindings/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.10
   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 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55565   unsigned int jresult ;
55566   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55567   bool result;
55568
55569   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55570   {
55571     try {
55572       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55573     } catch (std::out_of_range& e) {
55574       {
55575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55576       };
55577     } catch (std::exception& e) {
55578       {
55579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (...) {
55582       {
55583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55584       };
55585     }
55586   }
55587   jresult = result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55593   unsigned long jresult ;
55594   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55595   std::size_t result;
55596
55597   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55598   {
55599     try {
55600       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55601     } catch (std::out_of_range& e) {
55602       {
55603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55604       };
55605     } catch (std::exception& e) {
55606       {
55607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55608       };
55609     } catch (...) {
55610       {
55611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55612       };
55613     }
55614   }
55615   jresult = (unsigned long)result;
55616   return jresult;
55617 }
55618
55619
55620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55621   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55622   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55623
55624   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55625   arg2 = (void (*)(bool))jarg2;
55626   {
55627     try {
55628       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55629     } catch (std::out_of_range& e) {
55630       {
55631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55632       };
55633     } catch (std::exception& e) {
55634       {
55635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55636       };
55637     } catch (...) {
55638       {
55639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55640       };
55641     }
55642   }
55643 }
55644
55645
55646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55647   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55648   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55649
55650   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55651   arg2 = (void (*)(bool))jarg2;
55652   {
55653     try {
55654       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55655     } catch (std::out_of_range& e) {
55656       {
55657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55658       };
55659     } catch (std::exception& e) {
55660       {
55661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55662       };
55663     } catch (...) {
55664       {
55665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55666       };
55667     }
55668   }
55669 }
55670
55671
55672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55673   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55674   bool arg2 ;
55675
55676   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55677   arg2 = jarg2 ? true : false;
55678   {
55679     try {
55680       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55681     } catch (std::out_of_range& e) {
55682       {
55683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55684       };
55685     } catch (std::exception& e) {
55686       {
55687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55688       };
55689     } catch (...) {
55690       {
55691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55692       };
55693     }
55694   }
55695 }
55696
55697
55698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55699   void * jresult ;
55700   Dali::Signal< void (bool) > *result = 0 ;
55701
55702   {
55703     try {
55704       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55705     } catch (std::out_of_range& e) {
55706       {
55707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55708       };
55709     } catch (std::exception& e) {
55710       {
55711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (...) {
55714       {
55715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55716       };
55717     }
55718   }
55719   jresult = (void *)result;
55720   return jresult;
55721 }
55722
55723
55724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55725   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55726
55727   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55728   {
55729     try {
55730       delete arg1;
55731     } catch (std::out_of_range& e) {
55732       {
55733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55734       };
55735     } catch (std::exception& e) {
55736       {
55737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (...) {
55740       {
55741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55742       };
55743     }
55744   }
55745 }
55746
55747
55748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55749   int jresult ;
55750   int result;
55751
55752   {
55753     try {
55754       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55755     } catch (std::out_of_range& e) {
55756       {
55757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55758       };
55759     } catch (std::exception& e) {
55760       {
55761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55762       };
55763     } catch (...) {
55764       {
55765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55766       };
55767     }
55768   }
55769   jresult = (int)result;
55770   return jresult;
55771 }
55772
55773
55774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55775   int jresult ;
55776   int result;
55777
55778   {
55779     try {
55780       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55781     } catch (std::out_of_range& e) {
55782       {
55783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55784       };
55785     } catch (std::exception& e) {
55786       {
55787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55788       };
55789     } catch (...) {
55790       {
55791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55792       };
55793     }
55794   }
55795   jresult = (int)result;
55796   return jresult;
55797 }
55798
55799
55800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55801   int jresult ;
55802   int result;
55803
55804   {
55805     try {
55806       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55807     } catch (std::out_of_range& e) {
55808       {
55809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55810       };
55811     } catch (std::exception& e) {
55812       {
55813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55814       };
55815     } catch (...) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55818       };
55819     }
55820   }
55821   jresult = (int)result;
55822   return jresult;
55823 }
55824
55825
55826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55827   int jresult ;
55828   int result;
55829
55830   {
55831     try {
55832       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (...) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55844       };
55845     }
55846   }
55847   jresult = (int)result;
55848   return jresult;
55849 }
55850
55851
55852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55853   int jresult ;
55854   int result;
55855
55856   {
55857     try {
55858       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55859     } catch (std::out_of_range& e) {
55860       {
55861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55862       };
55863     } catch (std::exception& e) {
55864       {
55865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55866       };
55867     } catch (...) {
55868       {
55869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55870       };
55871     }
55872   }
55873   jresult = (int)result;
55874   return jresult;
55875 }
55876
55877
55878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55879   int jresult ;
55880   int result;
55881
55882   {
55883     try {
55884       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55885     } catch (std::out_of_range& e) {
55886       {
55887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55888       };
55889     } catch (std::exception& e) {
55890       {
55891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55892       };
55893     } catch (...) {
55894       {
55895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55896       };
55897     }
55898   }
55899   jresult = (int)result;
55900   return jresult;
55901 }
55902
55903
55904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55905   int jresult ;
55906   int result;
55907
55908   {
55909     try {
55910       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55911     } catch (std::out_of_range& e) {
55912       {
55913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55914       };
55915     } catch (std::exception& e) {
55916       {
55917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55918       };
55919     } catch (...) {
55920       {
55921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55922       };
55923     }
55924   }
55925   jresult = (int)result;
55926   return jresult;
55927 }
55928
55929
55930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55931   int jresult ;
55932   int result;
55933
55934   {
55935     try {
55936       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55937     } catch (std::out_of_range& e) {
55938       {
55939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (std::exception& e) {
55942       {
55943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55944       };
55945     } catch (...) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55948       };
55949     }
55950   }
55951   jresult = (int)result;
55952   return jresult;
55953 }
55954
55955
55956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55957   int jresult ;
55958   int result;
55959
55960   {
55961     try {
55962       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55963     } catch (std::out_of_range& e) {
55964       {
55965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55966       };
55967     } catch (std::exception& e) {
55968       {
55969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55970       };
55971     } catch (...) {
55972       {
55973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55974       };
55975     }
55976   }
55977   jresult = (int)result;
55978   return jresult;
55979 }
55980
55981
55982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55983   int jresult ;
55984   int result;
55985
55986   {
55987     try {
55988       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55989     } catch (std::out_of_range& e) {
55990       {
55991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55992       };
55993     } catch (std::exception& e) {
55994       {
55995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55996       };
55997     } catch (...) {
55998       {
55999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56000       };
56001     }
56002   }
56003   jresult = (int)result;
56004   return jresult;
56005 }
56006
56007
56008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56009   int jresult ;
56010   int result;
56011
56012   {
56013     try {
56014       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56015     } catch (std::out_of_range& e) {
56016       {
56017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (std::exception& e) {
56020       {
56021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56022       };
56023     } catch (...) {
56024       {
56025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56026       };
56027     }
56028   }
56029   jresult = (int)result;
56030   return jresult;
56031 }
56032
56033
56034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56035   int jresult ;
56036   int result;
56037
56038   {
56039     try {
56040       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56041     } catch (std::out_of_range& e) {
56042       {
56043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56044       };
56045     } catch (std::exception& e) {
56046       {
56047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56052       };
56053     }
56054   }
56055   jresult = (int)result;
56056   return jresult;
56057 }
56058
56059
56060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56061   int jresult ;
56062   int result;
56063
56064   {
56065     try {
56066       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56067     } catch (std::out_of_range& e) {
56068       {
56069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56070       };
56071     } catch (std::exception& e) {
56072       {
56073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (...) {
56076       {
56077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56078       };
56079     }
56080   }
56081   jresult = (int)result;
56082   return jresult;
56083 }
56084
56085
56086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56087   int jresult ;
56088   int result;
56089
56090   {
56091     try {
56092       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56093     } catch (std::out_of_range& e) {
56094       {
56095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56096       };
56097     } catch (std::exception& e) {
56098       {
56099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56100       };
56101     } catch (...) {
56102       {
56103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56104       };
56105     }
56106   }
56107   jresult = (int)result;
56108   return jresult;
56109 }
56110
56111
56112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56113   int jresult ;
56114   int result;
56115
56116   {
56117     try {
56118       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56119     } catch (std::out_of_range& e) {
56120       {
56121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56122       };
56123     } catch (std::exception& e) {
56124       {
56125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56126       };
56127     } catch (...) {
56128       {
56129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56130       };
56131     }
56132   }
56133   jresult = (int)result;
56134   return jresult;
56135 }
56136
56137
56138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56139   int jresult ;
56140   int result;
56141
56142   {
56143     try {
56144       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56145     } catch (std::out_of_range& e) {
56146       {
56147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56148       };
56149     } catch (std::exception& e) {
56150       {
56151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56152       };
56153     } catch (...) {
56154       {
56155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56156       };
56157     }
56158   }
56159   jresult = (int)result;
56160   return jresult;
56161 }
56162
56163
56164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56165   int jresult ;
56166   int result;
56167
56168   {
56169     try {
56170       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56171     } catch (std::out_of_range& e) {
56172       {
56173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56174       };
56175     } catch (std::exception& e) {
56176       {
56177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56178       };
56179     } catch (...) {
56180       {
56181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56182       };
56183     }
56184   }
56185   jresult = (int)result;
56186   return jresult;
56187 }
56188
56189
56190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56191   int jresult ;
56192   int result;
56193
56194   {
56195     try {
56196       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56197     } catch (std::out_of_range& e) {
56198       {
56199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (std::exception& e) {
56202       {
56203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (...) {
56206       {
56207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56208       };
56209     }
56210   }
56211   jresult = (int)result;
56212   return jresult;
56213 }
56214
56215
56216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56217   int jresult ;
56218   int result;
56219
56220   {
56221     try {
56222       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56223     } catch (std::out_of_range& e) {
56224       {
56225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56226       };
56227     } catch (std::exception& e) {
56228       {
56229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56230       };
56231     } catch (...) {
56232       {
56233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56234       };
56235     }
56236   }
56237   jresult = (int)result;
56238   return jresult;
56239 }
56240
56241
56242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56243   int jresult ;
56244   int result;
56245
56246   {
56247     try {
56248       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56249     } catch (std::out_of_range& e) {
56250       {
56251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56252       };
56253     } catch (std::exception& e) {
56254       {
56255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56256       };
56257     } catch (...) {
56258       {
56259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56260       };
56261     }
56262   }
56263   jresult = (int)result;
56264   return jresult;
56265 }
56266
56267
56268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56269   int jresult ;
56270   int result;
56271
56272   {
56273     try {
56274       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56275     } catch (std::out_of_range& e) {
56276       {
56277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56278       };
56279     } catch (std::exception& e) {
56280       {
56281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56286       };
56287     }
56288   }
56289   jresult = (int)result;
56290   return jresult;
56291 }
56292
56293
56294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56295   int jresult ;
56296   int result;
56297
56298   {
56299     try {
56300       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56308       };
56309     } catch (...) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56312       };
56313     }
56314   }
56315   jresult = (int)result;
56316   return jresult;
56317 }
56318
56319
56320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56321   int jresult ;
56322   int result;
56323
56324   {
56325     try {
56326       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56327     } catch (std::out_of_range& e) {
56328       {
56329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56330       };
56331     } catch (std::exception& e) {
56332       {
56333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56334       };
56335     } catch (...) {
56336       {
56337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56338       };
56339     }
56340   }
56341   jresult = (int)result;
56342   return jresult;
56343 }
56344
56345
56346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56347   int jresult ;
56348   int result;
56349
56350   {
56351     try {
56352       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56353     } catch (std::out_of_range& e) {
56354       {
56355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56356       };
56357     } catch (std::exception& e) {
56358       {
56359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56360       };
56361     } catch (...) {
56362       {
56363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56364       };
56365     }
56366   }
56367   jresult = (int)result;
56368   return jresult;
56369 }
56370
56371
56372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56373   int jresult ;
56374   int result;
56375
56376   {
56377     try {
56378       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56379     } catch (std::out_of_range& e) {
56380       {
56381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56382       };
56383     } catch (std::exception& e) {
56384       {
56385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56386       };
56387     } catch (...) {
56388       {
56389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56390       };
56391     }
56392   }
56393   jresult = (int)result;
56394   return jresult;
56395 }
56396
56397
56398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56399   int jresult ;
56400   int result;
56401
56402   {
56403     try {
56404       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56405     } catch (std::out_of_range& e) {
56406       {
56407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56408       };
56409     } catch (std::exception& e) {
56410       {
56411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56412       };
56413     } catch (...) {
56414       {
56415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56416       };
56417     }
56418   }
56419   jresult = (int)result;
56420   return jresult;
56421 }
56422
56423
56424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56425   int jresult ;
56426   int result;
56427
56428   {
56429     try {
56430       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56431     } catch (std::out_of_range& e) {
56432       {
56433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56434       };
56435     } catch (std::exception& e) {
56436       {
56437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56442       };
56443     }
56444   }
56445   jresult = (int)result;
56446   return jresult;
56447 }
56448
56449
56450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56451   int jresult ;
56452   int result;
56453
56454   {
56455     try {
56456       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56457     } catch (std::out_of_range& e) {
56458       {
56459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (std::exception& e) {
56462       {
56463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (...) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56468       };
56469     }
56470   }
56471   jresult = (int)result;
56472   return jresult;
56473 }
56474
56475
56476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56477   int jresult ;
56478   int result;
56479
56480   {
56481     try {
56482       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56483     } catch (std::out_of_range& e) {
56484       {
56485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56486       };
56487     } catch (std::exception& e) {
56488       {
56489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56490       };
56491     } catch (...) {
56492       {
56493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56494       };
56495     }
56496   }
56497   jresult = (int)result;
56498   return jresult;
56499 }
56500
56501
56502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56503   int jresult ;
56504   int result;
56505
56506   {
56507     try {
56508       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56509     } catch (std::out_of_range& e) {
56510       {
56511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56512       };
56513     } catch (std::exception& e) {
56514       {
56515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56516       };
56517     } catch (...) {
56518       {
56519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56520       };
56521     }
56522   }
56523   jresult = (int)result;
56524   return jresult;
56525 }
56526
56527
56528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56529   int jresult ;
56530   int result;
56531
56532   {
56533     try {
56534       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56542       };
56543     } catch (...) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56546       };
56547     }
56548   }
56549   jresult = (int)result;
56550   return jresult;
56551 }
56552
56553
56554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56555   int jresult ;
56556   int result;
56557
56558   {
56559     try {
56560       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56561     } catch (std::out_of_range& e) {
56562       {
56563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (std::exception& e) {
56566       {
56567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56568       };
56569     } catch (...) {
56570       {
56571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56572       };
56573     }
56574   }
56575   jresult = (int)result;
56576   return jresult;
56577 }
56578
56579
56580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56581   int jresult ;
56582   int result;
56583
56584   {
56585     try {
56586       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56587     } catch (std::out_of_range& e) {
56588       {
56589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56590       };
56591     } catch (std::exception& e) {
56592       {
56593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56594       };
56595     } catch (...) {
56596       {
56597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56598       };
56599     }
56600   }
56601   jresult = (int)result;
56602   return jresult;
56603 }
56604
56605
56606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56607   int jresult ;
56608   int result;
56609
56610   {
56611     try {
56612       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (...) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56624       };
56625     }
56626   }
56627   jresult = (int)result;
56628   return jresult;
56629 }
56630
56631
56632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56633   int jresult ;
56634   int result;
56635
56636   {
56637     try {
56638       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56639     } catch (std::out_of_range& e) {
56640       {
56641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56642       };
56643     } catch (std::exception& e) {
56644       {
56645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56646       };
56647     } catch (...) {
56648       {
56649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56650       };
56651     }
56652   }
56653   jresult = (int)result;
56654   return jresult;
56655 }
56656
56657
56658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56659   int jresult ;
56660   int result;
56661
56662   {
56663     try {
56664       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56665     } catch (std::out_of_range& e) {
56666       {
56667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56668       };
56669     } catch (std::exception& e) {
56670       {
56671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56672       };
56673     } catch (...) {
56674       {
56675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56676       };
56677     }
56678   }
56679   jresult = (int)result;
56680   return jresult;
56681 }
56682
56683
56684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56685   int jresult ;
56686   int result;
56687
56688   {
56689     try {
56690       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56691     } catch (std::out_of_range& e) {
56692       {
56693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56694       };
56695     } catch (std::exception& e) {
56696       {
56697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56698       };
56699     } catch (...) {
56700       {
56701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56702       };
56703     }
56704   }
56705   jresult = (int)result;
56706   return jresult;
56707 }
56708
56709
56710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56711   int jresult ;
56712   int result;
56713
56714   {
56715     try {
56716       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56717     } catch (std::out_of_range& e) {
56718       {
56719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56720       };
56721     } catch (std::exception& e) {
56722       {
56723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56724       };
56725     } catch (...) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56728       };
56729     }
56730   }
56731   jresult = (int)result;
56732   return jresult;
56733 }
56734
56735
56736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56737   int jresult ;
56738   int result;
56739
56740   {
56741     try {
56742       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56743     } catch (std::out_of_range& e) {
56744       {
56745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (std::exception& e) {
56748       {
56749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757   jresult = (int)result;
56758   return jresult;
56759 }
56760
56761
56762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56763   int jresult ;
56764   int result;
56765
56766   {
56767     try {
56768       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56769     } catch (std::out_of_range& e) {
56770       {
56771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56772       };
56773     } catch (std::exception& e) {
56774       {
56775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56776       };
56777     } catch (...) {
56778       {
56779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56780       };
56781     }
56782   }
56783   jresult = (int)result;
56784   return jresult;
56785 }
56786
56787
56788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56789   int jresult ;
56790   int result;
56791
56792   {
56793     try {
56794       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56795     } catch (std::out_of_range& e) {
56796       {
56797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56798       };
56799     } catch (std::exception& e) {
56800       {
56801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56802       };
56803     } catch (...) {
56804       {
56805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56806       };
56807     }
56808   }
56809   jresult = (int)result;
56810   return jresult;
56811 }
56812
56813
56814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56815   int jresult ;
56816   int result;
56817
56818   {
56819     try {
56820       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56821     } catch (std::out_of_range& e) {
56822       {
56823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56824       };
56825     } catch (std::exception& e) {
56826       {
56827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56828       };
56829     } catch (...) {
56830       {
56831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56832       };
56833     }
56834   }
56835   jresult = (int)result;
56836   return jresult;
56837 }
56838
56839
56840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56841   int jresult ;
56842   int result;
56843
56844   {
56845     try {
56846       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56847     } catch (std::out_of_range& e) {
56848       {
56849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56850       };
56851     } catch (std::exception& e) {
56852       {
56853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (...) {
56856       {
56857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56858       };
56859     }
56860   }
56861   jresult = (int)result;
56862   return jresult;
56863 }
56864
56865
56866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56867   int jresult ;
56868   int result;
56869
56870   {
56871     try {
56872       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56873     } catch (std::out_of_range& e) {
56874       {
56875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56876       };
56877     } catch (std::exception& e) {
56878       {
56879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56880       };
56881     } catch (...) {
56882       {
56883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56884       };
56885     }
56886   }
56887   jresult = (int)result;
56888   return jresult;
56889 }
56890
56891
56892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56893   int jresult ;
56894   int result;
56895
56896   {
56897     try {
56898       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56899     } catch (std::out_of_range& e) {
56900       {
56901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (std::exception& e) {
56904       {
56905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56910       };
56911     }
56912   }
56913   jresult = (int)result;
56914   return jresult;
56915 }
56916
56917
56918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56919   int jresult ;
56920   int result;
56921
56922   {
56923     try {
56924       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56925     } catch (std::out_of_range& e) {
56926       {
56927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56928       };
56929     } catch (std::exception& e) {
56930       {
56931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56932       };
56933     } catch (...) {
56934       {
56935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56936       };
56937     }
56938   }
56939   jresult = (int)result;
56940   return jresult;
56941 }
56942
56943
56944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56945   int jresult ;
56946   int result;
56947
56948   {
56949     try {
56950       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56951     } catch (std::out_of_range& e) {
56952       {
56953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (std::exception& e) {
56956       {
56957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56962       };
56963     }
56964   }
56965   jresult = (int)result;
56966   return jresult;
56967 }
56968
56969
56970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56971   int jresult ;
56972   int result;
56973
56974   {
56975     try {
56976       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56977     } catch (std::out_of_range& e) {
56978       {
56979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56980       };
56981     } catch (std::exception& e) {
56982       {
56983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56984       };
56985     } catch (...) {
56986       {
56987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56988       };
56989     }
56990   }
56991   jresult = (int)result;
56992   return jresult;
56993 }
56994
56995
56996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56997   int jresult ;
56998   int result;
56999
57000   {
57001     try {
57002       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57003     } catch (std::out_of_range& e) {
57004       {
57005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57006       };
57007     } catch (std::exception& e) {
57008       {
57009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (...) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57014       };
57015     }
57016   }
57017   jresult = (int)result;
57018   return jresult;
57019 }
57020
57021
57022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57023   int jresult ;
57024   int result;
57025
57026   {
57027     try {
57028       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57029     } catch (std::out_of_range& e) {
57030       {
57031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57032       };
57033     } catch (std::exception& e) {
57034       {
57035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57036       };
57037     } catch (...) {
57038       {
57039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57040       };
57041     }
57042   }
57043   jresult = (int)result;
57044   return jresult;
57045 }
57046
57047
57048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57049   int jresult ;
57050   int result;
57051
57052   {
57053     try {
57054       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57055     } catch (std::out_of_range& e) {
57056       {
57057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57058       };
57059     } catch (std::exception& e) {
57060       {
57061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57062       };
57063     } catch (...) {
57064       {
57065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57066       };
57067     }
57068   }
57069   jresult = (int)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57075   int jresult ;
57076   int result;
57077
57078   {
57079     try {
57080       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (...) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57092       };
57093     }
57094   }
57095   jresult = (int)result;
57096   return jresult;
57097 }
57098
57099
57100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57101   int jresult ;
57102   int result;
57103
57104   {
57105     try {
57106       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57107     } catch (std::out_of_range& e) {
57108       {
57109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57110       };
57111     } catch (std::exception& e) {
57112       {
57113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57114       };
57115     } catch (...) {
57116       {
57117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57118       };
57119     }
57120   }
57121   jresult = (int)result;
57122   return jresult;
57123 }
57124
57125
57126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57127   int jresult ;
57128   int result;
57129
57130   {
57131     try {
57132       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57133     } catch (std::out_of_range& e) {
57134       {
57135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57136       };
57137     } catch (std::exception& e) {
57138       {
57139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57140       };
57141     } catch (...) {
57142       {
57143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57144       };
57145     }
57146   }
57147   jresult = (int)result;
57148   return jresult;
57149 }
57150
57151
57152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57153   int jresult ;
57154   int result;
57155
57156   {
57157     try {
57158       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57159     } catch (std::out_of_range& e) {
57160       {
57161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57162       };
57163     } catch (std::exception& e) {
57164       {
57165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57166       };
57167     } catch (...) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57170       };
57171     }
57172   }
57173   jresult = (int)result;
57174   return jresult;
57175 }
57176
57177
57178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57179   int jresult ;
57180   int result;
57181
57182   {
57183     try {
57184       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57185     } catch (std::out_of_range& e) {
57186       {
57187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57188       };
57189     } catch (std::exception& e) {
57190       {
57191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57192       };
57193     } catch (...) {
57194       {
57195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57196       };
57197     }
57198   }
57199   jresult = (int)result;
57200   return jresult;
57201 }
57202
57203
57204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57205   int jresult ;
57206   int result;
57207
57208   {
57209     try {
57210       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57211     } catch (std::out_of_range& e) {
57212       {
57213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57214       };
57215     } catch (std::exception& e) {
57216       {
57217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57218       };
57219     } catch (...) {
57220       {
57221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57222       };
57223     }
57224   }
57225   jresult = (int)result;
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57231   void * jresult ;
57232   Dali::Toolkit::Builder *result = 0 ;
57233
57234   {
57235     try {
57236       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57237     } catch (std::out_of_range& e) {
57238       {
57239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (std::exception& e) {
57242       {
57243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57244       };
57245     } catch (...) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57248       };
57249     }
57250   }
57251   jresult = (void *)result;
57252   return jresult;
57253 }
57254
57255
57256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57257   void * jresult ;
57258   Dali::Toolkit::Builder result;
57259
57260   {
57261     try {
57262       result = Dali::Toolkit::Builder::New();
57263     } catch (std::out_of_range& e) {
57264       {
57265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57266       };
57267     } catch (std::exception& e) {
57268       {
57269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57270       };
57271     } catch (...) {
57272       {
57273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57274       };
57275     }
57276   }
57277   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57278   return jresult;
57279 }
57280
57281
57282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57283   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57284
57285   arg1 = (Dali::Toolkit::Builder *)jarg1;
57286   {
57287     try {
57288       delete arg1;
57289     } catch (std::out_of_range& e) {
57290       {
57291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57292       };
57293     } catch (std::exception& e) {
57294       {
57295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57300       };
57301     }
57302   }
57303 }
57304
57305
57306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57307   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57308   std::string *arg2 = 0 ;
57309   Dali::Toolkit::Builder::UIFormat arg3 ;
57310
57311   arg1 = (Dali::Toolkit::Builder *)jarg1;
57312   if (!jarg2) {
57313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57314     return ;
57315   }
57316   std::string arg2_str(jarg2);
57317   arg2 = &arg2_str;
57318   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57319   {
57320     try {
57321       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57322     } catch (std::out_of_range& e) {
57323       {
57324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57325       };
57326     } catch (std::exception& e) {
57327       {
57328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57329       };
57330     } catch (...) {
57331       {
57332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57333       };
57334     }
57335   }
57336
57337   //argout typemap for const std::string&
57338
57339 }
57340
57341
57342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57343   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57344   std::string *arg2 = 0 ;
57345
57346   arg1 = (Dali::Toolkit::Builder *)jarg1;
57347   if (!jarg2) {
57348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57349     return ;
57350   }
57351   std::string arg2_str(jarg2);
57352   arg2 = &arg2_str;
57353   {
57354     try {
57355       (arg1)->LoadFromString((std::string const &)*arg2);
57356     } catch (std::out_of_range& e) {
57357       {
57358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57359       };
57360     } catch (std::exception& e) {
57361       {
57362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57363       };
57364     } catch (...) {
57365       {
57366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57367       };
57368     }
57369   }
57370
57371   //argout typemap for const std::string&
57372
57373 }
57374
57375
57376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57377   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57378   Dali::Property::Map *arg2 = 0 ;
57379
57380   arg1 = (Dali::Toolkit::Builder *)jarg1;
57381   arg2 = (Dali::Property::Map *)jarg2;
57382   if (!arg2) {
57383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57384     return ;
57385   }
57386   {
57387     try {
57388       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57396       };
57397     } catch (...) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57400       };
57401     }
57402   }
57403 }
57404
57405
57406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57407   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57408   std::string *arg2 = 0 ;
57409   Dali::Property::Value *arg3 = 0 ;
57410
57411   arg1 = (Dali::Toolkit::Builder *)jarg1;
57412   if (!jarg2) {
57413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57414     return ;
57415   }
57416   std::string arg2_str(jarg2);
57417   arg2 = &arg2_str;
57418   arg3 = (Dali::Property::Value *)jarg3;
57419   if (!arg3) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57421     return ;
57422   }
57423   {
57424     try {
57425       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57426     } catch (std::out_of_range& e) {
57427       {
57428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57429       };
57430     } catch (std::exception& e) {
57431       {
57432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57433       };
57434     } catch (...) {
57435       {
57436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57437       };
57438     }
57439   }
57440
57441   //argout typemap for const std::string&
57442
57443 }
57444
57445
57446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57447   void * jresult ;
57448   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57449   Dali::Property::Map *result = 0 ;
57450
57451   arg1 = (Dali::Toolkit::Builder *)jarg1;
57452   {
57453     try {
57454       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57455     } catch (std::out_of_range& e) {
57456       {
57457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57458       };
57459     } catch (std::exception& e) {
57460       {
57461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57466       };
57467     }
57468   }
57469   jresult = (void *)result;
57470   return jresult;
57471 }
57472
57473
57474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57475   void * jresult ;
57476   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57477   std::string *arg2 = 0 ;
57478   Dali::Property::Value *result = 0 ;
57479
57480   arg1 = (Dali::Toolkit::Builder *)jarg1;
57481   if (!jarg2) {
57482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57483     return 0;
57484   }
57485   std::string arg2_str(jarg2);
57486   arg2 = &arg2_str;
57487   {
57488     try {
57489       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57490     } catch (std::out_of_range& e) {
57491       {
57492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57493       };
57494     } catch (std::exception& e) {
57495       {
57496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (...) {
57499       {
57500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57501       };
57502     }
57503   }
57504   jresult = (void *)result;
57505
57506   //argout typemap for const std::string&
57507
57508   return jresult;
57509 }
57510
57511
57512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57513   void * jresult ;
57514   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57515   std::string *arg2 = 0 ;
57516   Dali::Animation result;
57517
57518   arg1 = (Dali::Toolkit::Builder *)jarg1;
57519   if (!jarg2) {
57520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57521     return 0;
57522   }
57523   std::string arg2_str(jarg2);
57524   arg2 = &arg2_str;
57525   {
57526     try {
57527       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57528     } catch (std::out_of_range& e) {
57529       {
57530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (std::exception& e) {
57533       {
57534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57535       };
57536     } catch (...) {
57537       {
57538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57539       };
57540     }
57541   }
57542   jresult = new Dali::Animation((const Dali::Animation &)result);
57543
57544   //argout typemap for const std::string&
57545
57546   return jresult;
57547 }
57548
57549
57550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57551   void * jresult ;
57552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57553   std::string *arg2 = 0 ;
57554   Dali::Property::Map *arg3 = 0 ;
57555   Dali::Animation result;
57556
57557   arg1 = (Dali::Toolkit::Builder *)jarg1;
57558   if (!jarg2) {
57559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57560     return 0;
57561   }
57562   std::string arg2_str(jarg2);
57563   arg2 = &arg2_str;
57564   arg3 = (Dali::Property::Map *)jarg3;
57565   if (!arg3) {
57566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57567     return 0;
57568   }
57569   {
57570     try {
57571       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57572     } catch (std::out_of_range& e) {
57573       {
57574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (std::exception& e) {
57577       {
57578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (...) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57583       };
57584     }
57585   }
57586   jresult = new Dali::Animation((const Dali::Animation &)result);
57587
57588   //argout typemap for const std::string&
57589
57590   return jresult;
57591 }
57592
57593
57594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57595   void * jresult ;
57596   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57597   std::string *arg2 = 0 ;
57598   Dali::Actor arg3 ;
57599   Dali::Actor *argp3 ;
57600   Dali::Animation result;
57601
57602   arg1 = (Dali::Toolkit::Builder *)jarg1;
57603   if (!jarg2) {
57604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57605     return 0;
57606   }
57607   std::string arg2_str(jarg2);
57608   arg2 = &arg2_str;
57609   argp3 = (Dali::Actor *)jarg3;
57610   if (!argp3) {
57611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57612     return 0;
57613   }
57614   arg3 = *argp3;
57615   {
57616     try {
57617       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57618     } catch (std::out_of_range& e) {
57619       {
57620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57621       };
57622     } catch (std::exception& e) {
57623       {
57624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57625       };
57626     } catch (...) {
57627       {
57628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57629       };
57630     }
57631   }
57632   jresult = new Dali::Animation((const Dali::Animation &)result);
57633
57634   //argout typemap for const std::string&
57635
57636   return jresult;
57637 }
57638
57639
57640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57641   void * jresult ;
57642   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57643   std::string *arg2 = 0 ;
57644   Dali::Property::Map *arg3 = 0 ;
57645   Dali::Actor arg4 ;
57646   Dali::Actor *argp4 ;
57647   Dali::Animation result;
57648
57649   arg1 = (Dali::Toolkit::Builder *)jarg1;
57650   if (!jarg2) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57652     return 0;
57653   }
57654   std::string arg2_str(jarg2);
57655   arg2 = &arg2_str;
57656   arg3 = (Dali::Property::Map *)jarg3;
57657   if (!arg3) {
57658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57659     return 0;
57660   }
57661   argp4 = (Dali::Actor *)jarg4;
57662   if (!argp4) {
57663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57664     return 0;
57665   }
57666   arg4 = *argp4;
57667   {
57668     try {
57669       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57670     } catch (std::out_of_range& e) {
57671       {
57672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57673       };
57674     } catch (std::exception& e) {
57675       {
57676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57677       };
57678     } catch (...) {
57679       {
57680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57681       };
57682     }
57683   }
57684   jresult = new Dali::Animation((const Dali::Animation &)result);
57685
57686   //argout typemap for const std::string&
57687
57688   return jresult;
57689 }
57690
57691
57692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57693   void * jresult ;
57694   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57695   std::string *arg2 = 0 ;
57696   Dali::BaseHandle result;
57697
57698   arg1 = (Dali::Toolkit::Builder *)jarg1;
57699   if (!jarg2) {
57700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57701     return 0;
57702   }
57703   std::string arg2_str(jarg2);
57704   arg2 = &arg2_str;
57705   {
57706     try {
57707       result = (arg1)->Create((std::string const &)*arg2);
57708     } catch (std::out_of_range& e) {
57709       {
57710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57711       };
57712     } catch (std::exception& e) {
57713       {
57714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57715       };
57716     } catch (...) {
57717       {
57718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57719       };
57720     }
57721   }
57722   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57723
57724   //argout typemap for const std::string&
57725
57726   return jresult;
57727 }
57728
57729
57730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57731   void * jresult ;
57732   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57733   std::string *arg2 = 0 ;
57734   Dali::Property::Map *arg3 = 0 ;
57735   Dali::BaseHandle result;
57736
57737   arg1 = (Dali::Toolkit::Builder *)jarg1;
57738   if (!jarg2) {
57739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57740     return 0;
57741   }
57742   std::string arg2_str(jarg2);
57743   arg2 = &arg2_str;
57744   arg3 = (Dali::Property::Map *)jarg3;
57745   if (!arg3) {
57746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57747     return 0;
57748   }
57749   {
57750     try {
57751       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57752     } catch (std::out_of_range& e) {
57753       {
57754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57755       };
57756     } catch (std::exception& e) {
57757       {
57758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57759       };
57760     } catch (...) {
57761       {
57762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57763       };
57764     }
57765   }
57766   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57767
57768   //argout typemap for const std::string&
57769
57770   return jresult;
57771 }
57772
57773
57774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57775   void * jresult ;
57776   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57777   std::string *arg2 = 0 ;
57778   Dali::BaseHandle result;
57779
57780   arg1 = (Dali::Toolkit::Builder *)jarg1;
57781   if (!jarg2) {
57782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57783     return 0;
57784   }
57785   std::string arg2_str(jarg2);
57786   arg2 = &arg2_str;
57787   {
57788     try {
57789       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57790     } catch (std::out_of_range& e) {
57791       {
57792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57793       };
57794     } catch (std::exception& e) {
57795       {
57796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57797       };
57798     } catch (...) {
57799       {
57800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57801       };
57802     }
57803   }
57804   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57805
57806   //argout typemap for const std::string&
57807
57808   return jresult;
57809 }
57810
57811
57812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57813   unsigned int jresult ;
57814   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57815   std::string *arg2 = 0 ;
57816   Dali::Handle *arg3 = 0 ;
57817   bool result;
57818
57819   arg1 = (Dali::Toolkit::Builder *)jarg1;
57820   if (!jarg2) {
57821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57822     return 0;
57823   }
57824   std::string arg2_str(jarg2);
57825   arg2 = &arg2_str;
57826   arg3 = (Dali::Handle *)jarg3;
57827   if (!arg3) {
57828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57829     return 0;
57830   }
57831   {
57832     try {
57833       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57834     } catch (std::out_of_range& e) {
57835       {
57836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57837       };
57838     } catch (std::exception& e) {
57839       {
57840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57841       };
57842     } catch (...) {
57843       {
57844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57845       };
57846     }
57847   }
57848   jresult = result;
57849
57850   //argout typemap for const std::string&
57851
57852   return jresult;
57853 }
57854
57855
57856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57857   unsigned int jresult ;
57858   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57859   Dali::Handle *arg2 = 0 ;
57860   std::string *arg3 = 0 ;
57861   bool result;
57862
57863   arg1 = (Dali::Toolkit::Builder *)jarg1;
57864   arg2 = (Dali::Handle *)jarg2;
57865   if (!arg2) {
57866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57867     return 0;
57868   }
57869   if (!jarg3) {
57870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57871     return 0;
57872   }
57873   std::string arg3_str(jarg3);
57874   arg3 = &arg3_str;
57875   {
57876     try {
57877       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57878     } catch (std::out_of_range& e) {
57879       {
57880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57881       };
57882     } catch (std::exception& e) {
57883       {
57884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57885       };
57886     } catch (...) {
57887       {
57888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57889       };
57890     }
57891   }
57892   jresult = result;
57893
57894   //argout typemap for const std::string&
57895
57896   return jresult;
57897 }
57898
57899
57900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57901   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57902   Dali::Actor arg2 ;
57903   Dali::Actor *argp2 ;
57904
57905   arg1 = (Dali::Toolkit::Builder *)jarg1;
57906   argp2 = (Dali::Actor *)jarg2;
57907   if (!argp2) {
57908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57909     return ;
57910   }
57911   arg2 = *argp2;
57912   {
57913     try {
57914       (arg1)->AddActors(arg2);
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57922       };
57923     } catch (...) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57926       };
57927     }
57928   }
57929 }
57930
57931
57932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57933   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57934   std::string *arg2 = 0 ;
57935   Dali::Actor arg3 ;
57936   Dali::Actor *argp3 ;
57937
57938   arg1 = (Dali::Toolkit::Builder *)jarg1;
57939   if (!jarg2) {
57940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57941     return ;
57942   }
57943   std::string arg2_str(jarg2);
57944   arg2 = &arg2_str;
57945   argp3 = (Dali::Actor *)jarg3;
57946   if (!argp3) {
57947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57948     return ;
57949   }
57950   arg3 = *argp3;
57951   {
57952     try {
57953       (arg1)->AddActors((std::string const &)*arg2,arg3);
57954     } catch (std::out_of_range& e) {
57955       {
57956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57957       };
57958     } catch (std::exception& e) {
57959       {
57960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57961       };
57962     } catch (...) {
57963       {
57964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57965       };
57966     }
57967   }
57968
57969   //argout typemap for const std::string&
57970
57971 }
57972
57973
57974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57975   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57976   std::string *arg2 = 0 ;
57977
57978   arg1 = (Dali::Toolkit::Builder *)jarg1;
57979   if (!jarg2) {
57980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57981     return ;
57982   }
57983   std::string arg2_str(jarg2);
57984   arg2 = &arg2_str;
57985   {
57986     try {
57987       (arg1)->CreateRenderTask((std::string const &)*arg2);
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57999       };
58000     }
58001   }
58002
58003   //argout typemap for const std::string&
58004
58005 }
58006
58007
58008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58009   void * jresult ;
58010   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58011   std::string *arg2 = 0 ;
58012   Dali::FrameBufferImage result;
58013
58014   arg1 = (Dali::Toolkit::Builder *)jarg1;
58015   if (!jarg2) {
58016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58017     return 0;
58018   }
58019   std::string arg2_str(jarg2);
58020   arg2 = &arg2_str;
58021   {
58022     try {
58023       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58024     } catch (std::out_of_range& e) {
58025       {
58026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58027       };
58028     } catch (std::exception& e) {
58029       {
58030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58031       };
58032     } catch (...) {
58033       {
58034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58035       };
58036     }
58037   }
58038   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58039
58040   //argout typemap for const std::string&
58041
58042   return jresult;
58043 }
58044
58045
58046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58047   void * jresult ;
58048   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58049   std::string *arg2 = 0 ;
58050   Dali::Path result;
58051
58052   arg1 = (Dali::Toolkit::Builder *)jarg1;
58053   if (!jarg2) {
58054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58055     return 0;
58056   }
58057   std::string arg2_str(jarg2);
58058   arg2 = &arg2_str;
58059   {
58060     try {
58061       result = (arg1)->GetPath((std::string const &)*arg2);
58062     } catch (std::out_of_range& e) {
58063       {
58064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58065       };
58066     } catch (std::exception& e) {
58067       {
58068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (...) {
58071       {
58072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58073       };
58074     }
58075   }
58076   jresult = new Dali::Path((const Dali::Path &)result);
58077
58078   //argout typemap for const std::string&
58079
58080   return jresult;
58081 }
58082
58083
58084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58085   void * jresult ;
58086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58087   std::string *arg2 = 0 ;
58088   Dali::PathConstrainer result;
58089
58090   arg1 = (Dali::Toolkit::Builder *)jarg1;
58091   if (!jarg2) {
58092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58093     return 0;
58094   }
58095   std::string arg2_str(jarg2);
58096   arg2 = &arg2_str;
58097   {
58098     try {
58099       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58100     } catch (std::out_of_range& e) {
58101       {
58102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58103       };
58104     } catch (std::exception& e) {
58105       {
58106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58107       };
58108     } catch (...) {
58109       {
58110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58111       };
58112     }
58113   }
58114   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58115
58116   //argout typemap for const std::string&
58117
58118   return jresult;
58119 }
58120
58121
58122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58123   void * jresult ;
58124   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58125   std::string *arg2 = 0 ;
58126   Dali::LinearConstrainer result;
58127
58128   arg1 = (Dali::Toolkit::Builder *)jarg1;
58129   if (!jarg2) {
58130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58131     return 0;
58132   }
58133   std::string arg2_str(jarg2);
58134   arg2 = &arg2_str;
58135   {
58136     try {
58137       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58138     } catch (std::out_of_range& e) {
58139       {
58140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (std::exception& e) {
58143       {
58144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58145       };
58146     } catch (...) {
58147       {
58148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58149       };
58150     }
58151   }
58152   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58153
58154   //argout typemap for const std::string&
58155
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58161   void * jresult ;
58162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58163   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58164
58165   arg1 = (Dali::Toolkit::Builder *)jarg1;
58166   {
58167     try {
58168       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58169     } catch (std::out_of_range& e) {
58170       {
58171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58172       };
58173     } catch (std::exception& e) {
58174       {
58175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58176       };
58177     } catch (...) {
58178       {
58179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58180       };
58181     }
58182   }
58183   jresult = (void *)result;
58184   return jresult;
58185 }
58186
58187
58188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58189   void * jresult ;
58190   Dali::Toolkit::TransitionData *result = 0 ;
58191
58192   {
58193     try {
58194       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58195     } catch (std::out_of_range& e) {
58196       {
58197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58198       };
58199     } catch (std::exception& e) {
58200       {
58201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58202       };
58203     } catch (...) {
58204       {
58205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58206       };
58207     }
58208   }
58209   jresult = (void *)result;
58210   return jresult;
58211 }
58212
58213
58214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58215   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58216
58217   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58218   {
58219     try {
58220       delete arg1;
58221     } catch (std::out_of_range& e) {
58222       {
58223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58224       };
58225     } catch (std::exception& e) {
58226       {
58227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58228       };
58229     } catch (...) {
58230       {
58231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58232       };
58233     }
58234   }
58235 }
58236
58237
58238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58239   void * jresult ;
58240   Dali::Property::Map *arg1 = 0 ;
58241   Dali::Toolkit::TransitionData result;
58242
58243   arg1 = (Dali::Property::Map *)jarg1;
58244   if (!arg1) {
58245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58246     return 0;
58247   }
58248   {
58249     try {
58250       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58251     } catch (std::out_of_range& e) {
58252       {
58253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58254       };
58255     } catch (std::exception& e) {
58256       {
58257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (...) {
58260       {
58261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58262       };
58263     }
58264   }
58265   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58266   return jresult;
58267 }
58268
58269
58270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58271   void * jresult ;
58272   Dali::Property::Array *arg1 = 0 ;
58273   Dali::Toolkit::TransitionData result;
58274
58275   arg1 = (Dali::Property::Array *)jarg1;
58276   if (!arg1) {
58277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58278     return 0;
58279   }
58280   {
58281     try {
58282       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58283     } catch (std::out_of_range& e) {
58284       {
58285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58286       };
58287     } catch (std::exception& e) {
58288       {
58289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58290       };
58291     } catch (...) {
58292       {
58293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58294       };
58295     }
58296   }
58297   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58298   return jresult;
58299 }
58300
58301
58302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58303   void * jresult ;
58304   Dali::BaseHandle arg1 ;
58305   Dali::BaseHandle *argp1 ;
58306   Dali::Toolkit::TransitionData result;
58307
58308   argp1 = (Dali::BaseHandle *)jarg1;
58309   if (!argp1) {
58310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58311     return 0;
58312   }
58313   arg1 = *argp1;
58314   {
58315     try {
58316       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58317     } catch (std::out_of_range& e) {
58318       {
58319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58320       };
58321     } catch (std::exception& e) {
58322       {
58323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58324       };
58325     } catch (...) {
58326       {
58327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58328       };
58329     }
58330   }
58331   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58332   return jresult;
58333 }
58334
58335
58336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58337   void * jresult ;
58338   Dali::Toolkit::TransitionData *arg1 = 0 ;
58339   Dali::Toolkit::TransitionData *result = 0 ;
58340
58341   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58342   if (!arg1) {
58343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58344     return 0;
58345   }
58346   {
58347     try {
58348       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58349     } catch (std::out_of_range& e) {
58350       {
58351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58352       };
58353     } catch (std::exception& e) {
58354       {
58355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58356       };
58357     } catch (...) {
58358       {
58359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58360       };
58361     }
58362   }
58363   jresult = (void *)result;
58364   return jresult;
58365 }
58366
58367
58368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58369   void * jresult ;
58370   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58371   Dali::Toolkit::TransitionData *arg2 = 0 ;
58372   Dali::Toolkit::TransitionData *result = 0 ;
58373
58374   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58375   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58376   if (!arg2) {
58377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58378     return 0;
58379   }
58380   {
58381     try {
58382       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58383     } catch (std::out_of_range& e) {
58384       {
58385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58386       };
58387     } catch (std::exception& e) {
58388       {
58389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58390       };
58391     } catch (...) {
58392       {
58393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58394       };
58395     }
58396   }
58397   jresult = (void *)result;
58398   return jresult;
58399 }
58400
58401
58402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58403   unsigned long jresult ;
58404   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58405   size_t result;
58406
58407   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58408   {
58409     try {
58410       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58411     } catch (std::out_of_range& e) {
58412       {
58413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58414       };
58415     } catch (std::exception& e) {
58416       {
58417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58418       };
58419     } catch (...) {
58420       {
58421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58422       };
58423     }
58424   }
58425   jresult = (unsigned long)result;
58426   return jresult;
58427 }
58428
58429
58430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58431   void * jresult ;
58432   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58433   size_t arg2 ;
58434   Dali::Property::Map result;
58435
58436   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58437   arg2 = (size_t)jarg2;
58438   {
58439     try {
58440       result = (arg1)->GetAnimatorAt(arg2);
58441     } catch (std::out_of_range& e) {
58442       {
58443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58444       };
58445     } catch (std::exception& e) {
58446       {
58447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58448       };
58449     } catch (...) {
58450       {
58451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58452       };
58453     }
58454   }
58455   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58456   return jresult;
58457 }
58458
58459
58460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58461   void * jresult ;
58462   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58463   Dali::Toolkit::TransitionData *result = 0 ;
58464
58465   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58466   {
58467     try {
58468       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58469     } catch (std::out_of_range& e) {
58470       {
58471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (std::exception& e) {
58474       {
58475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (...) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58480       };
58481     }
58482   }
58483   jresult = (void *)result;
58484   return jresult;
58485 }
58486
58487
58488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58489   int jresult ;
58490   int result;
58491
58492   {
58493     try {
58494       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58495     } catch (std::out_of_range& e) {
58496       {
58497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58498       };
58499     } catch (std::exception& e) {
58500       {
58501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58502       };
58503     } catch (...) {
58504       {
58505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58506       };
58507     }
58508   }
58509   jresult = (int)result;
58510   return jresult;
58511 }
58512
58513
58514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58515   int jresult ;
58516   int result;
58517
58518   {
58519     try {
58520       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58521     } catch (std::out_of_range& e) {
58522       {
58523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58524       };
58525     } catch (std::exception& e) {
58526       {
58527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58528       };
58529     } catch (...) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58532       };
58533     }
58534   }
58535   jresult = (int)result;
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58541   int jresult ;
58542   int result;
58543
58544   {
58545     try {
58546       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58547     } catch (std::out_of_range& e) {
58548       {
58549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58550       };
58551     } catch (std::exception& e) {
58552       {
58553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58554       };
58555     } catch (...) {
58556       {
58557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58558       };
58559     }
58560   }
58561   jresult = (int)result;
58562   return jresult;
58563 }
58564
58565
58566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58567   int jresult ;
58568   int result;
58569
58570   {
58571     try {
58572       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58573     } catch (std::out_of_range& e) {
58574       {
58575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58576       };
58577     } catch (std::exception& e) {
58578       {
58579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58580       };
58581     } catch (...) {
58582       {
58583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58584       };
58585     }
58586   }
58587   jresult = (int)result;
58588   return jresult;
58589 }
58590
58591
58592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58593   int jresult ;
58594   int result;
58595
58596   {
58597     try {
58598       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58599     } catch (std::out_of_range& e) {
58600       {
58601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58602       };
58603     } catch (std::exception& e) {
58604       {
58605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58606       };
58607     } catch (...) {
58608       {
58609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58610       };
58611     }
58612   }
58613   jresult = (int)result;
58614   return jresult;
58615 }
58616
58617
58618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58619   int jresult ;
58620   int result;
58621
58622   {
58623     try {
58624       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58625     } catch (std::out_of_range& e) {
58626       {
58627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58628       };
58629     } catch (std::exception& e) {
58630       {
58631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (...) {
58634       {
58635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58636       };
58637     }
58638   }
58639   jresult = (int)result;
58640   return jresult;
58641 }
58642
58643
58644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58645   int jresult ;
58646   int result;
58647
58648   {
58649     try {
58650       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58651     } catch (std::out_of_range& e) {
58652       {
58653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58654       };
58655     } catch (std::exception& e) {
58656       {
58657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (...) {
58660       {
58661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58662       };
58663     }
58664   }
58665   jresult = (int)result;
58666   return jresult;
58667 }
58668
58669
58670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58671   int jresult ;
58672   int result;
58673
58674   {
58675     try {
58676       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58677     } catch (std::out_of_range& e) {
58678       {
58679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58680       };
58681     } catch (std::exception& e) {
58682       {
58683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58684       };
58685     } catch (...) {
58686       {
58687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58688       };
58689     }
58690   }
58691   jresult = (int)result;
58692   return jresult;
58693 }
58694
58695
58696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58697   int jresult ;
58698   int result;
58699
58700   {
58701     try {
58702       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58703     } catch (std::out_of_range& e) {
58704       {
58705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58706       };
58707     } catch (std::exception& e) {
58708       {
58709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (...) {
58712       {
58713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58714       };
58715     }
58716   }
58717   jresult = (int)result;
58718   return jresult;
58719 }
58720
58721
58722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58723   int jresult ;
58724   int result;
58725
58726   {
58727     try {
58728       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58729     } catch (std::out_of_range& e) {
58730       {
58731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58732       };
58733     } catch (std::exception& e) {
58734       {
58735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58736       };
58737     } catch (...) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58740       };
58741     }
58742   }
58743   jresult = (int)result;
58744   return jresult;
58745 }
58746
58747
58748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58749   int jresult ;
58750   int result;
58751
58752   {
58753     try {
58754       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58755     } catch (std::out_of_range& e) {
58756       {
58757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (std::exception& e) {
58760       {
58761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58762       };
58763     } catch (...) {
58764       {
58765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58766       };
58767     }
58768   }
58769   jresult = (int)result;
58770   return jresult;
58771 }
58772
58773
58774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58775   int jresult ;
58776   int result;
58777
58778   {
58779     try {
58780       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58781     } catch (std::out_of_range& e) {
58782       {
58783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58784       };
58785     } catch (std::exception& e) {
58786       {
58787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58788       };
58789     } catch (...) {
58790       {
58791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58792       };
58793     }
58794   }
58795   jresult = (int)result;
58796   return jresult;
58797 }
58798
58799
58800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58801   int jresult ;
58802   int result;
58803
58804   {
58805     try {
58806       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58807     } catch (std::out_of_range& e) {
58808       {
58809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58810       };
58811     } catch (std::exception& e) {
58812       {
58813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58814       };
58815     } catch (...) {
58816       {
58817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58818       };
58819     }
58820   }
58821   jresult = (int)result;
58822   return jresult;
58823 }
58824
58825
58826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58827   int jresult ;
58828   int result;
58829
58830   {
58831     try {
58832       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58833     } catch (std::out_of_range& e) {
58834       {
58835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58836       };
58837     } catch (std::exception& e) {
58838       {
58839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (...) {
58842       {
58843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58844       };
58845     }
58846   }
58847   jresult = (int)result;
58848   return jresult;
58849 }
58850
58851
58852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58853   void * jresult ;
58854   Dali::Toolkit::Control result;
58855
58856   {
58857     try {
58858       result = Dali::Toolkit::Internal::Control::New();
58859     } catch (std::out_of_range& e) {
58860       {
58861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (std::exception& e) {
58864       {
58865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58866       };
58867     } catch (...) {
58868       {
58869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58870       };
58871     }
58872   }
58873   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58874   return jresult;
58875 }
58876
58877
58878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58880   std::string *arg2 = 0 ;
58881
58882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58883   if (!jarg2) {
58884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58885     return ;
58886   }
58887   std::string arg2_str(jarg2);
58888   arg2 = &arg2_str;
58889   {
58890     try {
58891       (arg1)->SetStyleName((std::string const &)*arg2);
58892     } catch (std::out_of_range& e) {
58893       {
58894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58895       };
58896     } catch (std::exception& e) {
58897       {
58898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58899       };
58900     } catch (...) {
58901       {
58902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58903       };
58904     }
58905   }
58906
58907   //argout typemap for const std::string&
58908
58909 }
58910
58911
58912 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58913   char * jresult ;
58914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58915   std::string *result = 0 ;
58916
58917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58918   {
58919     try {
58920       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58921     } catch (std::out_of_range& e) {
58922       {
58923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (std::exception& e) {
58926       {
58927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (...) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58932       };
58933     }
58934   }
58935   jresult = SWIG_csharp_string_callback(result->c_str());
58936   return jresult;
58937 }
58938
58939
58940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58942   Dali::Vector4 *arg2 = 0 ;
58943
58944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58945   arg2 = (Dali::Vector4 *)jarg2;
58946   if (!arg2) {
58947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58948     return ;
58949   }
58950   {
58951     try {
58952       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58960       };
58961     } catch (...) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58964       };
58965     }
58966   }
58967 }
58968
58969
58970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58971   void * jresult ;
58972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58973   Dali::Vector4 result;
58974
58975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58976   {
58977     try {
58978       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (...) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58990       };
58991     }
58992   }
58993   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58994   return jresult;
58995 }
58996
58997
58998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
58999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59000   Dali::Image arg2 ;
59001   Dali::Image *argp2 ;
59002
59003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59004   argp2 = (Dali::Image *)jarg2;
59005   if (!argp2) {
59006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59007     return ;
59008   }
59009   arg2 = *argp2;
59010   {
59011     try {
59012       (arg1)->SetBackgroundImage(arg2);
59013     } catch (std::out_of_range& e) {
59014       {
59015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59016       };
59017     } catch (std::exception& e) {
59018       {
59019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59024       };
59025     }
59026   }
59027 }
59028
59029
59030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59032   Dali::Property::Map *arg2 = 0 ;
59033
59034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59035   arg2 = (Dali::Property::Map *)jarg2;
59036   if (!arg2) {
59037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59038     return ;
59039   }
59040   {
59041     try {
59042       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59043     } catch (std::out_of_range& e) {
59044       {
59045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59046       };
59047     } catch (std::exception& e) {
59048       {
59049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59050       };
59051     } catch (...) {
59052       {
59053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59054       };
59055     }
59056   }
59057 }
59058
59059
59060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59062
59063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59064   {
59065     try {
59066       (arg1)->ClearBackground();
59067     } catch (std::out_of_range& e) {
59068       {
59069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59070       };
59071     } catch (std::exception& e) {
59072       {
59073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59078       };
59079     }
59080   }
59081 }
59082
59083
59084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59086   Dali::Gesture::Type arg2 ;
59087
59088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59089   arg2 = (Dali::Gesture::Type)jarg2;
59090   {
59091     try {
59092       (arg1)->EnableGestureDetection(arg2);
59093     } catch (std::out_of_range& e) {
59094       {
59095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59096       };
59097     } catch (std::exception& e) {
59098       {
59099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59100       };
59101     } catch (...) {
59102       {
59103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59104       };
59105     }
59106   }
59107 }
59108
59109
59110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59112   Dali::Gesture::Type arg2 ;
59113
59114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59115   arg2 = (Dali::Gesture::Type)jarg2;
59116   {
59117     try {
59118       (arg1)->DisableGestureDetection(arg2);
59119     } catch (std::out_of_range& e) {
59120       {
59121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59122       };
59123     } catch (std::exception& e) {
59124       {
59125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59126       };
59127     } catch (...) {
59128       {
59129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59130       };
59131     }
59132   }
59133 }
59134
59135
59136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59137   void * jresult ;
59138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59139   Dali::PinchGestureDetector result;
59140
59141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59142   {
59143     try {
59144       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59145     } catch (std::out_of_range& e) {
59146       {
59147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59148       };
59149     } catch (std::exception& e) {
59150       {
59151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59152       };
59153     } catch (...) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59156       };
59157     }
59158   }
59159   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59160   return jresult;
59161 }
59162
59163
59164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59165   void * jresult ;
59166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59167   Dali::PanGestureDetector result;
59168
59169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59170   {
59171     try {
59172       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59173     } catch (std::out_of_range& e) {
59174       {
59175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (std::exception& e) {
59178       {
59179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (...) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59184       };
59185     }
59186   }
59187   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59193   void * jresult ;
59194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59195   Dali::TapGestureDetector result;
59196
59197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59198   {
59199     try {
59200       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59201     } catch (std::out_of_range& e) {
59202       {
59203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59204       };
59205     } catch (std::exception& e) {
59206       {
59207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59208       };
59209     } catch (...) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59212       };
59213     }
59214   }
59215   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59216   return jresult;
59217 }
59218
59219
59220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59221   void * jresult ;
59222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59223   Dali::LongPressGestureDetector result;
59224
59225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59226   {
59227     try {
59228       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59240       };
59241     }
59242   }
59243   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59250   bool arg2 ;
59251
59252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59253   arg2 = jarg2 ? true : false;
59254   {
59255     try {
59256       (arg1)->SetKeyboardNavigationSupport(arg2);
59257     } catch (std::out_of_range& e) {
59258       {
59259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59260       };
59261     } catch (std::exception& e) {
59262       {
59263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59264       };
59265     } catch (...) {
59266       {
59267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59268       };
59269     }
59270   }
59271 }
59272
59273
59274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59275   unsigned int jresult ;
59276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59277   bool result;
59278
59279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59280   {
59281     try {
59282       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59283     } catch (std::out_of_range& e) {
59284       {
59285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (std::exception& e) {
59288       {
59289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59290       };
59291     } catch (...) {
59292       {
59293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59294       };
59295     }
59296   }
59297   jresult = result;
59298   return jresult;
59299 }
59300
59301
59302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59304
59305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59306   {
59307     try {
59308       (arg1)->SetKeyInputFocus();
59309     } catch (std::out_of_range& e) {
59310       {
59311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59312       };
59313     } catch (std::exception& e) {
59314       {
59315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59316       };
59317     } catch (...) {
59318       {
59319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59320       };
59321     }
59322   }
59323 }
59324
59325
59326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59327   unsigned int jresult ;
59328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59329   bool result;
59330
59331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59332   {
59333     try {
59334       result = (bool)(arg1)->HasKeyInputFocus();
59335     } catch (std::out_of_range& e) {
59336       {
59337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59338       };
59339     } catch (std::exception& e) {
59340       {
59341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59342       };
59343     } catch (...) {
59344       {
59345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59346       };
59347     }
59348   }
59349   jresult = result;
59350   return jresult;
59351 }
59352
59353
59354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59356
59357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59358   {
59359     try {
59360       (arg1)->ClearKeyInputFocus();
59361     } catch (std::out_of_range& e) {
59362       {
59363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59364       };
59365     } catch (std::exception& e) {
59366       {
59367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59368       };
59369     } catch (...) {
59370       {
59371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59372       };
59373     }
59374   }
59375 }
59376
59377
59378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59380   bool arg2 ;
59381
59382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59383   arg2 = jarg2 ? true : false;
59384   {
59385     try {
59386       (arg1)->SetAsKeyboardFocusGroup(arg2);
59387     } catch (std::out_of_range& e) {
59388       {
59389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59390       };
59391     } catch (std::exception& e) {
59392       {
59393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59394       };
59395     } catch (...) {
59396       {
59397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59398       };
59399     }
59400   }
59401 }
59402
59403
59404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59405   unsigned int jresult ;
59406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59407   bool result;
59408
59409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59410   {
59411     try {
59412       result = (bool)(arg1)->IsKeyboardFocusGroup();
59413     } catch (std::out_of_range& e) {
59414       {
59415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59416       };
59417     } catch (std::exception& e) {
59418       {
59419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59420       };
59421     } catch (...) {
59422       {
59423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59424       };
59425     }
59426   }
59427   jresult = result;
59428   return jresult;
59429 }
59430
59431
59432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59434
59435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59436   {
59437     try {
59438       (arg1)->AccessibilityActivate();
59439     } catch (std::out_of_range& e) {
59440       {
59441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59442       };
59443     } catch (std::exception& e) {
59444       {
59445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59450       };
59451     }
59452   }
59453 }
59454
59455
59456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59458
59459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59460   {
59461     try {
59462       (arg1)->KeyboardEnter();
59463     } catch (std::out_of_range& e) {
59464       {
59465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59466       };
59467     } catch (std::exception& e) {
59468       {
59469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59470       };
59471     } catch (...) {
59472       {
59473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59474       };
59475     }
59476   }
59477 }
59478
59479
59480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59481   void * jresult ;
59482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59483   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59484
59485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59486   {
59487     try {
59488       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59489     } catch (std::out_of_range& e) {
59490       {
59491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59492       };
59493     } catch (std::exception& e) {
59494       {
59495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59496       };
59497     } catch (...) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59500       };
59501     }
59502   }
59503   jresult = (void *)result;
59504   return jresult;
59505 }
59506
59507
59508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59509   void * jresult ;
59510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59511   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59512
59513   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59514   {
59515     try {
59516       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59517     } catch (std::out_of_range& e) {
59518       {
59519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (std::exception& e) {
59522       {
59523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59524       };
59525     } catch (...) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59528       };
59529     }
59530   }
59531   jresult = (void *)result;
59532   return jresult;
59533 }
59534
59535
59536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59537   void * jresult ;
59538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59539   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59540
59541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59542   {
59543     try {
59544       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59545     } catch (std::out_of_range& e) {
59546       {
59547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59548       };
59549     } catch (std::exception& e) {
59550       {
59551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59552       };
59553     } catch (...) {
59554       {
59555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59556       };
59557     }
59558   }
59559   jresult = (void *)result;
59560   return jresult;
59561 }
59562
59563
59564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59565   unsigned int jresult ;
59566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59567   Dali::KeyEvent *arg2 = 0 ;
59568   bool result;
59569
59570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59571   arg2 = (Dali::KeyEvent *)jarg2;
59572   if (!arg2) {
59573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59574     return 0;
59575   }
59576   {
59577     try {
59578       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59579     } catch (std::out_of_range& e) {
59580       {
59581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59582       };
59583     } catch (std::exception& e) {
59584       {
59585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59586       };
59587     } catch (...) {
59588       {
59589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59590       };
59591     }
59592   }
59593   jresult = result;
59594   return jresult;
59595 }
59596
59597
59598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59600   int arg2 ;
59601   SwigDirector_ViewImpl *darg = 0;
59602
59603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59604   arg2 = (int)jarg2;
59605   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59606   {
59607     try {
59608       (darg)->OnStageConnection(arg2);
59609     } catch (std::out_of_range& e) {
59610       {
59611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59612       };
59613     } catch (std::exception& e) {
59614       {
59615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59616       };
59617     } catch (...) {
59618       {
59619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59620       };
59621     }
59622   }
59623 }
59624
59625
59626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59628   int arg2 ;
59629   SwigDirector_ViewImpl *darg = 0;
59630
59631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59632   arg2 = (int)jarg2;
59633   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59634   {
59635     try {
59636       (darg)->OnStageConnectionSwigPublic(arg2);
59637     } catch (std::out_of_range& e) {
59638       {
59639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59640       };
59641     } catch (std::exception& e) {
59642       {
59643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59644       };
59645     } catch (...) {
59646       {
59647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59648       };
59649     }
59650   }
59651 }
59652
59653
59654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59656   SwigDirector_ViewImpl *darg = 0;
59657
59658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59659   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59660   {
59661     try {
59662       (darg)->OnStageDisconnection();
59663     } catch (std::out_of_range& e) {
59664       {
59665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59666       };
59667     } catch (std::exception& e) {
59668       {
59669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59670       };
59671     } catch (...) {
59672       {
59673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59674       };
59675     }
59676   }
59677 }
59678
59679
59680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59682   SwigDirector_ViewImpl *darg = 0;
59683
59684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59686   {
59687     try {
59688       (darg)->OnStageDisconnectionSwigPublic();
59689     } catch (std::out_of_range& e) {
59690       {
59691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59692       };
59693     } catch (std::exception& e) {
59694       {
59695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59696       };
59697     } catch (...) {
59698       {
59699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59700       };
59701     }
59702   }
59703 }
59704
59705
59706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59708   Dali::Actor *arg2 = 0 ;
59709   SwigDirector_ViewImpl *darg = 0;
59710
59711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59712   arg2 = (Dali::Actor *)jarg2;
59713   if (!arg2) {
59714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59715     return ;
59716   }
59717   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59718   {
59719     try {
59720       (darg)->OnChildAdd(*arg2);
59721     } catch (std::out_of_range& e) {
59722       {
59723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59724       };
59725     } catch (std::exception& e) {
59726       {
59727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59728       };
59729     } catch (...) {
59730       {
59731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59732       };
59733     }
59734   }
59735 }
59736
59737
59738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59740   Dali::Actor *arg2 = 0 ;
59741   SwigDirector_ViewImpl *darg = 0;
59742
59743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59744   arg2 = (Dali::Actor *)jarg2;
59745   if (!arg2) {
59746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59747     return ;
59748   }
59749   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59750   {
59751     try {
59752       (darg)->OnChildAddSwigPublic(*arg2);
59753     } catch (std::out_of_range& e) {
59754       {
59755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59756       };
59757     } catch (std::exception& e) {
59758       {
59759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59760       };
59761     } catch (...) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59764       };
59765     }
59766   }
59767 }
59768
59769
59770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59772   Dali::Actor *arg2 = 0 ;
59773   SwigDirector_ViewImpl *darg = 0;
59774
59775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59776   arg2 = (Dali::Actor *)jarg2;
59777   if (!arg2) {
59778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59779     return ;
59780   }
59781   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59782   {
59783     try {
59784       (darg)->OnChildRemove(*arg2);
59785     } catch (std::out_of_range& e) {
59786       {
59787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59788       };
59789     } catch (std::exception& e) {
59790       {
59791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59792       };
59793     } catch (...) {
59794       {
59795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59796       };
59797     }
59798   }
59799 }
59800
59801
59802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59804   Dali::Actor *arg2 = 0 ;
59805   SwigDirector_ViewImpl *darg = 0;
59806
59807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59808   arg2 = (Dali::Actor *)jarg2;
59809   if (!arg2) {
59810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59811     return ;
59812   }
59813   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59814   {
59815     try {
59816       (darg)->OnChildRemoveSwigPublic(*arg2);
59817     } catch (std::out_of_range& e) {
59818       {
59819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59820       };
59821     } catch (std::exception& e) {
59822       {
59823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59824       };
59825     } catch (...) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59828       };
59829     }
59830   }
59831 }
59832
59833
59834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59836   Dali::Property::Index arg2 ;
59837   Dali::Property::Value arg3 ;
59838   Dali::Property::Value *argp3 ;
59839   SwigDirector_ViewImpl *darg = 0;
59840
59841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59842   arg2 = (Dali::Property::Index)jarg2;
59843   argp3 = (Dali::Property::Value *)jarg3;
59844   if (!argp3) {
59845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59846     return ;
59847   }
59848   arg3 = *argp3;
59849   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59850   {
59851     try {
59852       (darg)->OnPropertySet(arg2,arg3);
59853     } catch (std::out_of_range& e) {
59854       {
59855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59856       };
59857     } catch (std::exception& e) {
59858       {
59859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59860       };
59861     } catch (...) {
59862       {
59863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59864       };
59865     }
59866   }
59867 }
59868
59869
59870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59872   Dali::Property::Index arg2 ;
59873   Dali::Property::Value arg3 ;
59874   Dali::Property::Value *argp3 ;
59875   SwigDirector_ViewImpl *darg = 0;
59876
59877   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59878   arg2 = (Dali::Property::Index)jarg2;
59879   argp3 = (Dali::Property::Value *)jarg3;
59880   if (!argp3) {
59881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59882     return ;
59883   }
59884   arg3 = *argp3;
59885   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59886   {
59887     try {
59888       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59889     } catch (std::out_of_range& e) {
59890       {
59891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59892       };
59893     } catch (std::exception& e) {
59894       {
59895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59896       };
59897     } catch (...) {
59898       {
59899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59900       };
59901     }
59902   }
59903 }
59904
59905
59906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59908   Dali::Vector3 *arg2 = 0 ;
59909   SwigDirector_ViewImpl *darg = 0;
59910
59911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59912   arg2 = (Dali::Vector3 *)jarg2;
59913   if (!arg2) {
59914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59915     return ;
59916   }
59917   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59918   {
59919     try {
59920       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59921     } catch (std::out_of_range& e) {
59922       {
59923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59924       };
59925     } catch (std::exception& e) {
59926       {
59927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59928       };
59929     } catch (...) {
59930       {
59931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59932       };
59933     }
59934   }
59935 }
59936
59937
59938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59940   Dali::Vector3 *arg2 = 0 ;
59941   SwigDirector_ViewImpl *darg = 0;
59942
59943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59944   arg2 = (Dali::Vector3 *)jarg2;
59945   if (!arg2) {
59946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59947     return ;
59948   }
59949   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59950   {
59951     try {
59952       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59953     } catch (std::out_of_range& e) {
59954       {
59955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59956       };
59957     } catch (std::exception& e) {
59958       {
59959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59960       };
59961     } catch (...) {
59962       {
59963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59964       };
59965     }
59966   }
59967 }
59968
59969
59970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59972   Dali::Animation *arg2 = 0 ;
59973   Dali::Vector3 *arg3 = 0 ;
59974   SwigDirector_ViewImpl *darg = 0;
59975
59976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59977   arg2 = (Dali::Animation *)jarg2;
59978   if (!arg2) {
59979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59980     return ;
59981   }
59982   arg3 = (Dali::Vector3 *)jarg3;
59983   if (!arg3) {
59984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59985     return ;
59986   }
59987   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59988   {
59989     try {
59990       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59998       };
59999     } catch (...) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60002       };
60003     }
60004   }
60005 }
60006
60007
60008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60010   Dali::Animation *arg2 = 0 ;
60011   Dali::Vector3 *arg3 = 0 ;
60012   SwigDirector_ViewImpl *darg = 0;
60013
60014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60015   arg2 = (Dali::Animation *)jarg2;
60016   if (!arg2) {
60017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60018     return ;
60019   }
60020   arg3 = (Dali::Vector3 *)jarg3;
60021   if (!arg3) {
60022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60023     return ;
60024   }
60025   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60026   {
60027     try {
60028       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60029     } catch (std::out_of_range& e) {
60030       {
60031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60032       };
60033     } catch (std::exception& e) {
60034       {
60035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60036       };
60037     } catch (...) {
60038       {
60039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60040       };
60041     }
60042   }
60043 }
60044
60045
60046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60047   unsigned int jresult ;
60048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60049   Dali::TouchEvent *arg2 = 0 ;
60050   SwigDirector_ViewImpl *darg = 0;
60051   bool result;
60052
60053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60054   arg2 = (Dali::TouchEvent *)jarg2;
60055   if (!arg2) {
60056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60057     return 0;
60058   }
60059   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60060   {
60061     try {
60062       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60063     } catch (std::out_of_range& e) {
60064       {
60065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60066       };
60067     } catch (std::exception& e) {
60068       {
60069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60070       };
60071     } catch (...) {
60072       {
60073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60074       };
60075     }
60076   }
60077   jresult = result;
60078   return jresult;
60079 }
60080
60081
60082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60083   unsigned int jresult ;
60084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60085   Dali::TouchEvent *arg2 = 0 ;
60086   SwigDirector_ViewImpl *darg = 0;
60087   bool result;
60088
60089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60090   arg2 = (Dali::TouchEvent *)jarg2;
60091   if (!arg2) {
60092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60093     return 0;
60094   }
60095   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60096   {
60097     try {
60098       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60099     } catch (std::out_of_range& e) {
60100       {
60101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60102       };
60103     } catch (std::exception& e) {
60104       {
60105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60106       };
60107     } catch (...) {
60108       {
60109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60110       };
60111     }
60112   }
60113   jresult = result;
60114   return jresult;
60115 }
60116
60117
60118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60119   unsigned int jresult ;
60120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60121   Dali::HoverEvent *arg2 = 0 ;
60122   SwigDirector_ViewImpl *darg = 0;
60123   bool result;
60124
60125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60126   arg2 = (Dali::HoverEvent *)jarg2;
60127   if (!arg2) {
60128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60129     return 0;
60130   }
60131   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60132   {
60133     try {
60134       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (...) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60146       };
60147     }
60148   }
60149   jresult = result;
60150   return jresult;
60151 }
60152
60153
60154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60155   unsigned int jresult ;
60156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60157   Dali::HoverEvent *arg2 = 0 ;
60158   SwigDirector_ViewImpl *darg = 0;
60159   bool result;
60160
60161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60162   arg2 = (Dali::HoverEvent *)jarg2;
60163   if (!arg2) {
60164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60165     return 0;
60166   }
60167   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60168   {
60169     try {
60170       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60171     } catch (std::out_of_range& e) {
60172       {
60173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60174       };
60175     } catch (std::exception& e) {
60176       {
60177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (...) {
60180       {
60181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60182       };
60183     }
60184   }
60185   jresult = result;
60186   return jresult;
60187 }
60188
60189
60190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60191   unsigned int jresult ;
60192   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60193   Dali::KeyEvent *arg2 = 0 ;
60194   SwigDirector_ViewImpl *darg = 0;
60195   bool result;
60196
60197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60198   arg2 = (Dali::KeyEvent *)jarg2;
60199   if (!arg2) {
60200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60201     return 0;
60202   }
60203   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60204   {
60205     try {
60206       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60207     } catch (std::out_of_range& e) {
60208       {
60209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (std::exception& e) {
60212       {
60213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (...) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60218       };
60219     }
60220   }
60221   jresult = result;
60222   return jresult;
60223 }
60224
60225
60226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60227   unsigned int jresult ;
60228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60229   Dali::KeyEvent *arg2 = 0 ;
60230   SwigDirector_ViewImpl *darg = 0;
60231   bool result;
60232
60233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60234   arg2 = (Dali::KeyEvent *)jarg2;
60235   if (!arg2) {
60236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60237     return 0;
60238   }
60239   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60240   {
60241     try {
60242       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60243     } catch (std::out_of_range& e) {
60244       {
60245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (std::exception& e) {
60248       {
60249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (...) {
60252       {
60253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60254       };
60255     }
60256   }
60257   jresult = result;
60258   return jresult;
60259 }
60260
60261
60262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60263   unsigned int jresult ;
60264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60265   Dali::WheelEvent *arg2 = 0 ;
60266   SwigDirector_ViewImpl *darg = 0;
60267   bool result;
60268
60269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60270   arg2 = (Dali::WheelEvent *)jarg2;
60271   if (!arg2) {
60272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60273     return 0;
60274   }
60275   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60276   {
60277     try {
60278       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60279     } catch (std::out_of_range& e) {
60280       {
60281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (std::exception& e) {
60284       {
60285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (...) {
60288       {
60289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60290       };
60291     }
60292   }
60293   jresult = result;
60294   return jresult;
60295 }
60296
60297
60298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60299   unsigned int jresult ;
60300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60301   Dali::WheelEvent *arg2 = 0 ;
60302   SwigDirector_ViewImpl *darg = 0;
60303   bool result;
60304
60305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60306   arg2 = (Dali::WheelEvent *)jarg2;
60307   if (!arg2) {
60308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60309     return 0;
60310   }
60311   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60312   {
60313     try {
60314       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60315     } catch (std::out_of_range& e) {
60316       {
60317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (std::exception& e) {
60320       {
60321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (...) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60326       };
60327     }
60328   }
60329   jresult = result;
60330   return jresult;
60331 }
60332
60333
60334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60336   Dali::Vector2 *arg2 = 0 ;
60337   Dali::RelayoutContainer *arg3 = 0 ;
60338   SwigDirector_ViewImpl *darg = 0;
60339
60340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60341   arg2 = (Dali::Vector2 *)jarg2;
60342   if (!arg2) {
60343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60344     return ;
60345   }
60346   arg3 = (Dali::RelayoutContainer *)jarg3;
60347   if (!arg3) {
60348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60349     return ;
60350   }
60351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60352   {
60353     try {
60354       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60355     } catch (std::out_of_range& e) {
60356       {
60357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60358       };
60359     } catch (std::exception& e) {
60360       {
60361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60362       };
60363     } catch (...) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60366       };
60367     }
60368   }
60369 }
60370
60371
60372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60374   Dali::Vector2 *arg2 = 0 ;
60375   Dali::RelayoutContainer *arg3 = 0 ;
60376   SwigDirector_ViewImpl *darg = 0;
60377
60378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60379   arg2 = (Dali::Vector2 *)jarg2;
60380   if (!arg2) {
60381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60382     return ;
60383   }
60384   arg3 = (Dali::RelayoutContainer *)jarg3;
60385   if (!arg3) {
60386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60387     return ;
60388   }
60389   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60390   {
60391     try {
60392       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60393     } catch (std::out_of_range& e) {
60394       {
60395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60396       };
60397     } catch (std::exception& e) {
60398       {
60399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60400       };
60401     } catch (...) {
60402       {
60403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60404       };
60405     }
60406   }
60407 }
60408
60409
60410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60412   Dali::ResizePolicy::Type arg2 ;
60413   Dali::Dimension::Type arg3 ;
60414   SwigDirector_ViewImpl *darg = 0;
60415
60416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60417   arg2 = (Dali::ResizePolicy::Type)jarg2;
60418   arg3 = (Dali::Dimension::Type)jarg3;
60419   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60420   {
60421     try {
60422       (darg)->OnSetResizePolicy(arg2,arg3);
60423     } catch (std::out_of_range& e) {
60424       {
60425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60426       };
60427     } catch (std::exception& e) {
60428       {
60429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60430       };
60431     } catch (...) {
60432       {
60433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60434       };
60435     }
60436   }
60437 }
60438
60439
60440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60442   Dali::ResizePolicy::Type arg2 ;
60443   Dali::Dimension::Type arg3 ;
60444   SwigDirector_ViewImpl *darg = 0;
60445
60446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60447   arg2 = (Dali::ResizePolicy::Type)jarg2;
60448   arg3 = (Dali::Dimension::Type)jarg3;
60449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60450   {
60451     try {
60452       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60453     } catch (std::out_of_range& e) {
60454       {
60455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60456       };
60457     } catch (std::exception& e) {
60458       {
60459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60460       };
60461     } catch (...) {
60462       {
60463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60464       };
60465     }
60466   }
60467 }
60468
60469
60470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60471   void * jresult ;
60472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60473   SwigDirector_ViewImpl *darg = 0;
60474   Dali::Vector3 result;
60475
60476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60477   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60478   {
60479     try {
60480       result = (darg)->GetNaturalSize();
60481     } catch (std::out_of_range& e) {
60482       {
60483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60484       };
60485     } catch (std::exception& e) {
60486       {
60487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (...) {
60490       {
60491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60492       };
60493     }
60494   }
60495   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60496   return jresult;
60497 }
60498
60499
60500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60501   void * jresult ;
60502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60503   SwigDirector_ViewImpl *darg = 0;
60504   Dali::Vector3 result;
60505
60506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60508   {
60509     try {
60510       result = (darg)->GetNaturalSizeSwigPublic();
60511     } catch (std::out_of_range& e) {
60512       {
60513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60514       };
60515     } catch (std::exception& e) {
60516       {
60517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60518       };
60519     } catch (...) {
60520       {
60521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60522       };
60523     }
60524   }
60525   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60526   return jresult;
60527 }
60528
60529
60530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60531   float jresult ;
60532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60533   Dali::Actor *arg2 = 0 ;
60534   Dali::Dimension::Type arg3 ;
60535   SwigDirector_ViewImpl *darg = 0;
60536   float result;
60537
60538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60539   arg2 = (Dali::Actor *)jarg2;
60540   if (!arg2) {
60541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60542     return 0;
60543   }
60544   arg3 = (Dali::Dimension::Type)jarg3;
60545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60546   {
60547     try {
60548       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60549     } catch (std::out_of_range& e) {
60550       {
60551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (std::exception& e) {
60554       {
60555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60556       };
60557     } catch (...) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60560       };
60561     }
60562   }
60563   jresult = result;
60564   return jresult;
60565 }
60566
60567
60568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60569   float jresult ;
60570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60571   Dali::Actor *arg2 = 0 ;
60572   Dali::Dimension::Type arg3 ;
60573   SwigDirector_ViewImpl *darg = 0;
60574   float result;
60575
60576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60577   arg2 = (Dali::Actor *)jarg2;
60578   if (!arg2) {
60579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60580     return 0;
60581   }
60582   arg3 = (Dali::Dimension::Type)jarg3;
60583   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60584   {
60585     try {
60586       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60587     } catch (std::out_of_range& e) {
60588       {
60589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60590       };
60591     } catch (std::exception& e) {
60592       {
60593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60594       };
60595     } catch (...) {
60596       {
60597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60598       };
60599     }
60600   }
60601   jresult = result;
60602   return jresult;
60603 }
60604
60605
60606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60607   float jresult ;
60608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60609   float arg2 ;
60610   SwigDirector_ViewImpl *darg = 0;
60611   float result;
60612
60613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60614   arg2 = (float)jarg2;
60615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60616   {
60617     try {
60618       result = (float)(darg)->GetHeightForWidth(arg2);
60619     } catch (std::out_of_range& e) {
60620       {
60621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (std::exception& e) {
60624       {
60625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633   jresult = result;
60634   return jresult;
60635 }
60636
60637
60638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60639   float jresult ;
60640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60641   float arg2 ;
60642   SwigDirector_ViewImpl *darg = 0;
60643   float result;
60644
60645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60646   arg2 = (float)jarg2;
60647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60648   {
60649     try {
60650       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60651     } catch (std::out_of_range& e) {
60652       {
60653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60654       };
60655     } catch (std::exception& e) {
60656       {
60657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (...) {
60660       {
60661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60662       };
60663     }
60664   }
60665   jresult = result;
60666   return jresult;
60667 }
60668
60669
60670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60671   float jresult ;
60672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60673   float arg2 ;
60674   SwigDirector_ViewImpl *darg = 0;
60675   float result;
60676
60677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60678   arg2 = (float)jarg2;
60679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60680   {
60681     try {
60682       result = (float)(darg)->GetWidthForHeight(arg2);
60683     } catch (std::out_of_range& e) {
60684       {
60685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60686       };
60687     } catch (std::exception& e) {
60688       {
60689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60690       };
60691     } catch (...) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60694       };
60695     }
60696   }
60697   jresult = result;
60698   return jresult;
60699 }
60700
60701
60702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60703   float jresult ;
60704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60705   float arg2 ;
60706   SwigDirector_ViewImpl *darg = 0;
60707   float result;
60708
60709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60710   arg2 = (float)jarg2;
60711   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60712   {
60713     try {
60714       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60715     } catch (std::out_of_range& e) {
60716       {
60717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60718       };
60719     } catch (std::exception& e) {
60720       {
60721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60722       };
60723     } catch (...) {
60724       {
60725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60726       };
60727     }
60728   }
60729   jresult = result;
60730   return jresult;
60731 }
60732
60733
60734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60735   unsigned int jresult ;
60736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60737   Dali::Dimension::Type arg2 ;
60738   SwigDirector_ViewImpl *darg = 0;
60739   bool result;
60740
60741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60742   arg2 = (Dali::Dimension::Type)jarg2;
60743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60744   {
60745     try {
60746       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60747     } catch (std::out_of_range& e) {
60748       {
60749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60750       };
60751     } catch (std::exception& e) {
60752       {
60753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (...) {
60756       {
60757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60758       };
60759     }
60760   }
60761   jresult = result;
60762   return jresult;
60763 }
60764
60765
60766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60767   unsigned int jresult ;
60768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60769   Dali::Dimension::Type arg2 ;
60770   SwigDirector_ViewImpl *darg = 0;
60771   bool result;
60772
60773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60774   arg2 = (Dali::Dimension::Type)jarg2;
60775   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60776   {
60777     try {
60778       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60779     } catch (std::out_of_range& e) {
60780       {
60781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60782       };
60783     } catch (std::exception& e) {
60784       {
60785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60786       };
60787     } catch (...) {
60788       {
60789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60790       };
60791     }
60792   }
60793   jresult = result;
60794   return jresult;
60795 }
60796
60797
60798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60799   unsigned int jresult ;
60800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60801   SwigDirector_ViewImpl *darg = 0;
60802   bool result;
60803
60804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60805   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60806   {
60807     try {
60808       result = (bool)(darg)->RelayoutDependentOnChildren();
60809     } catch (std::out_of_range& e) {
60810       {
60811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60812       };
60813     } catch (std::exception& e) {
60814       {
60815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60816       };
60817     } catch (...) {
60818       {
60819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60820       };
60821     }
60822   }
60823   jresult = result;
60824   return jresult;
60825 }
60826
60827
60828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60829   unsigned int jresult ;
60830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60831   SwigDirector_ViewImpl *darg = 0;
60832   bool result;
60833
60834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60835   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60836   {
60837     try {
60838       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60839     } catch (std::out_of_range& e) {
60840       {
60841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60842       };
60843     } catch (std::exception& e) {
60844       {
60845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60846       };
60847     } catch (...) {
60848       {
60849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60850       };
60851     }
60852   }
60853   jresult = result;
60854   return jresult;
60855 }
60856
60857
60858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60860   Dali::Dimension::Type arg2 ;
60861   SwigDirector_ViewImpl *darg = 0;
60862
60863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60864   arg2 = (Dali::Dimension::Type)jarg2;
60865   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60866   {
60867     try {
60868       (darg)->OnCalculateRelayoutSize(arg2);
60869     } catch (std::out_of_range& e) {
60870       {
60871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60872       };
60873     } catch (std::exception& e) {
60874       {
60875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60876       };
60877     } catch (...) {
60878       {
60879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60880       };
60881     }
60882   }
60883 }
60884
60885
60886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60888   Dali::Dimension::Type arg2 ;
60889   SwigDirector_ViewImpl *darg = 0;
60890
60891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60892   arg2 = (Dali::Dimension::Type)jarg2;
60893   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60894   {
60895     try {
60896       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60897     } catch (std::out_of_range& e) {
60898       {
60899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60900       };
60901     } catch (std::exception& e) {
60902       {
60903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60904       };
60905     } catch (...) {
60906       {
60907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60908       };
60909     }
60910   }
60911 }
60912
60913
60914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60916   float arg2 ;
60917   Dali::Dimension::Type arg3 ;
60918   SwigDirector_ViewImpl *darg = 0;
60919
60920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60921   arg2 = (float)jarg2;
60922   arg3 = (Dali::Dimension::Type)jarg3;
60923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60924   {
60925     try {
60926       (darg)->OnLayoutNegotiated(arg2,arg3);
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60938       };
60939     }
60940   }
60941 }
60942
60943
60944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60946   float arg2 ;
60947   Dali::Dimension::Type arg3 ;
60948   SwigDirector_ViewImpl *darg = 0;
60949
60950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60951   arg2 = (float)jarg2;
60952   arg3 = (Dali::Dimension::Type)jarg3;
60953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60954   {
60955     try {
60956       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60957     } catch (std::out_of_range& e) {
60958       {
60959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60960       };
60961     } catch (std::exception& e) {
60962       {
60963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60964       };
60965     } catch (...) {
60966       {
60967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60968       };
60969     }
60970   }
60971 }
60972
60973
60974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60976
60977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60978   {
60979     try {
60980       (arg1)->OnInitialize();
60981     } catch (std::out_of_range& e) {
60982       {
60983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60984       };
60985     } catch (std::exception& e) {
60986       {
60987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60988       };
60989     } catch (...) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60992       };
60993     }
60994   }
60995 }
60996
60997
60998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
60999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61000
61001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61002   {
61003     try {
61004       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61005     } catch (std::out_of_range& e) {
61006       {
61007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61008       };
61009     } catch (std::exception& e) {
61010       {
61011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61012       };
61013     } catch (...) {
61014       {
61015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61016       };
61017     }
61018   }
61019 }
61020
61021
61022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61024   Dali::Actor *arg2 = 0 ;
61025
61026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61027   arg2 = (Dali::Actor *)jarg2;
61028   if (!arg2) {
61029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61030     return ;
61031   }
61032   {
61033     try {
61034       (arg1)->OnControlChildAdd(*arg2);
61035     } catch (std::out_of_range& e) {
61036       {
61037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61038       };
61039     } catch (std::exception& e) {
61040       {
61041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61042       };
61043     } catch (...) {
61044       {
61045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61046       };
61047     }
61048   }
61049 }
61050
61051
61052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61054   Dali::Actor *arg2 = 0 ;
61055
61056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61057   arg2 = (Dali::Actor *)jarg2;
61058   if (!arg2) {
61059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61060     return ;
61061   }
61062   {
61063     try {
61064       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61065     } catch (std::out_of_range& e) {
61066       {
61067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61068       };
61069     } catch (std::exception& e) {
61070       {
61071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61072       };
61073     } catch (...) {
61074       {
61075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61076       };
61077     }
61078   }
61079 }
61080
61081
61082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61084   Dali::Actor *arg2 = 0 ;
61085
61086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61087   arg2 = (Dali::Actor *)jarg2;
61088   if (!arg2) {
61089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61090     return ;
61091   }
61092   {
61093     try {
61094       (arg1)->OnControlChildRemove(*arg2);
61095     } catch (std::out_of_range& e) {
61096       {
61097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61098       };
61099     } catch (std::exception& e) {
61100       {
61101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61102       };
61103     } catch (...) {
61104       {
61105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61106       };
61107     }
61108   }
61109 }
61110
61111
61112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61114   Dali::Actor *arg2 = 0 ;
61115
61116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61117   arg2 = (Dali::Actor *)jarg2;
61118   if (!arg2) {
61119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61120     return ;
61121   }
61122   {
61123     try {
61124       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61125     } catch (std::out_of_range& e) {
61126       {
61127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61128       };
61129     } catch (std::exception& e) {
61130       {
61131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61132       };
61133     } catch (...) {
61134       {
61135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61136       };
61137     }
61138   }
61139 }
61140
61141
61142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61144   Dali::Toolkit::StyleManager arg2 ;
61145   Dali::StyleChange::Type arg3 ;
61146   Dali::Toolkit::StyleManager *argp2 ;
61147
61148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61149   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61150   if (!argp2) {
61151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61152     return ;
61153   }
61154   arg2 = *argp2;
61155   arg3 = (Dali::StyleChange::Type)jarg3;
61156   {
61157     try {
61158       (arg1)->OnStyleChange(arg2,arg3);
61159     } catch (std::out_of_range& e) {
61160       {
61161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61162       };
61163     } catch (std::exception& e) {
61164       {
61165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61166       };
61167     } catch (...) {
61168       {
61169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61170       };
61171     }
61172   }
61173 }
61174
61175
61176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61178   Dali::Toolkit::StyleManager arg2 ;
61179   Dali::StyleChange::Type arg3 ;
61180   Dali::Toolkit::StyleManager *argp2 ;
61181
61182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61183   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61184   if (!argp2) {
61185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61186     return ;
61187   }
61188   arg2 = *argp2;
61189   arg3 = (Dali::StyleChange::Type)jarg3;
61190   {
61191     try {
61192       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61193     } catch (std::out_of_range& e) {
61194       {
61195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61196       };
61197     } catch (std::exception& e) {
61198       {
61199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61200       };
61201     } catch (...) {
61202       {
61203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61204       };
61205     }
61206   }
61207 }
61208
61209
61210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61211   unsigned int jresult ;
61212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61213   bool result;
61214
61215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61216   {
61217     try {
61218       result = (bool)(arg1)->OnAccessibilityActivated();
61219     } catch (std::out_of_range& e) {
61220       {
61221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61222       };
61223     } catch (std::exception& e) {
61224       {
61225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61226       };
61227     } catch (...) {
61228       {
61229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61230       };
61231     }
61232   }
61233   jresult = result;
61234   return jresult;
61235 }
61236
61237
61238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61239   unsigned int jresult ;
61240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61241   bool result;
61242
61243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61244   {
61245     try {
61246       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61247     } catch (std::out_of_range& e) {
61248       {
61249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (std::exception& e) {
61252       {
61253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61254       };
61255     } catch (...) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61258       };
61259     }
61260   }
61261   jresult = result;
61262   return jresult;
61263 }
61264
61265
61266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61267   unsigned int jresult ;
61268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61269   Dali::PanGesture arg2 ;
61270   Dali::PanGesture *argp2 ;
61271   bool result;
61272
61273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61274   argp2 = (Dali::PanGesture *)jarg2;
61275   if (!argp2) {
61276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61277     return 0;
61278   }
61279   arg2 = *argp2;
61280   {
61281     try {
61282       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61283     } catch (std::out_of_range& e) {
61284       {
61285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61286       };
61287     } catch (std::exception& e) {
61288       {
61289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (...) {
61292       {
61293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61294       };
61295     }
61296   }
61297   jresult = result;
61298   return jresult;
61299 }
61300
61301
61302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61303   unsigned int jresult ;
61304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61305   Dali::PanGesture arg2 ;
61306   Dali::PanGesture *argp2 ;
61307   bool result;
61308
61309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61310   argp2 = (Dali::PanGesture *)jarg2;
61311   if (!argp2) {
61312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61313     return 0;
61314   }
61315   arg2 = *argp2;
61316   {
61317     try {
61318       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61319     } catch (std::out_of_range& e) {
61320       {
61321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (std::exception& e) {
61324       {
61325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61326       };
61327     } catch (...) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61330       };
61331     }
61332   }
61333   jresult = result;
61334   return jresult;
61335 }
61336
61337
61338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61339   unsigned int jresult ;
61340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61341   Dali::TouchEvent *arg2 = 0 ;
61342   bool result;
61343
61344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61345   arg2 = (Dali::TouchEvent *)jarg2;
61346   if (!arg2) {
61347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61348     return 0;
61349   }
61350   {
61351     try {
61352       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61353     } catch (std::out_of_range& e) {
61354       {
61355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (std::exception& e) {
61358       {
61359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61360       };
61361     } catch (...) {
61362       {
61363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61364       };
61365     }
61366   }
61367   jresult = result;
61368   return jresult;
61369 }
61370
61371
61372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61373   unsigned int jresult ;
61374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61375   Dali::TouchEvent *arg2 = 0 ;
61376   bool result;
61377
61378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61379   arg2 = (Dali::TouchEvent *)jarg2;
61380   if (!arg2) {
61381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61382     return 0;
61383   }
61384   {
61385     try {
61386       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61387     } catch (std::out_of_range& e) {
61388       {
61389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61390       };
61391     } catch (std::exception& e) {
61392       {
61393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61394       };
61395     } catch (...) {
61396       {
61397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61398       };
61399     }
61400   }
61401   jresult = result;
61402   return jresult;
61403 }
61404
61405
61406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61407   unsigned int jresult ;
61408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61409   bool arg2 ;
61410   bool result;
61411
61412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61413   arg2 = jarg2 ? true : false;
61414   {
61415     try {
61416       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61417     } catch (std::out_of_range& e) {
61418       {
61419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61420       };
61421     } catch (std::exception& e) {
61422       {
61423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61424       };
61425     } catch (...) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61428       };
61429     }
61430   }
61431   jresult = result;
61432   return jresult;
61433 }
61434
61435
61436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61437   unsigned int jresult ;
61438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61439   bool arg2 ;
61440   bool result;
61441
61442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61443   arg2 = jarg2 ? true : false;
61444   {
61445     try {
61446       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61447     } catch (std::out_of_range& e) {
61448       {
61449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61450       };
61451     } catch (std::exception& e) {
61452       {
61453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61454       };
61455     } catch (...) {
61456       {
61457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61458       };
61459     }
61460   }
61461   jresult = result;
61462   return jresult;
61463 }
61464
61465
61466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61467   unsigned int jresult ;
61468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61469   bool result;
61470
61471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61472   {
61473     try {
61474       result = (bool)(arg1)->OnAccessibilityZoom();
61475     } catch (std::out_of_range& e) {
61476       {
61477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61478       };
61479     } catch (std::exception& e) {
61480       {
61481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61482       };
61483     } catch (...) {
61484       {
61485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61486       };
61487     }
61488   }
61489   jresult = result;
61490   return jresult;
61491 }
61492
61493
61494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61495   unsigned int jresult ;
61496   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61497   bool result;
61498
61499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61500   {
61501     try {
61502       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61503     } catch (std::out_of_range& e) {
61504       {
61505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61506       };
61507     } catch (std::exception& e) {
61508       {
61509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (...) {
61512       {
61513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61514       };
61515     }
61516   }
61517   jresult = result;
61518   return jresult;
61519 }
61520
61521
61522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61523   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61524
61525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61526   {
61527     try {
61528       (arg1)->OnKeyInputFocusGained();
61529     } catch (std::out_of_range& e) {
61530       {
61531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61532       };
61533     } catch (std::exception& e) {
61534       {
61535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61536       };
61537     } catch (...) {
61538       {
61539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61540       };
61541     }
61542   }
61543 }
61544
61545
61546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61548
61549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61550   {
61551     try {
61552       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61553     } catch (std::out_of_range& e) {
61554       {
61555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61556       };
61557     } catch (std::exception& e) {
61558       {
61559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61560       };
61561     } catch (...) {
61562       {
61563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61564       };
61565     }
61566   }
61567 }
61568
61569
61570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61572
61573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61574   {
61575     try {
61576       (arg1)->OnKeyInputFocusLost();
61577     } catch (std::out_of_range& e) {
61578       {
61579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61580       };
61581     } catch (std::exception& e) {
61582       {
61583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61584       };
61585     } catch (...) {
61586       {
61587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61588       };
61589     }
61590   }
61591 }
61592
61593
61594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61595   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61596
61597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61598   {
61599     try {
61600       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61601     } catch (std::out_of_range& e) {
61602       {
61603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61604       };
61605     } catch (std::exception& e) {
61606       {
61607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61612       };
61613     }
61614   }
61615 }
61616
61617
61618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61619   void * jresult ;
61620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61621   Dali::Actor arg2 ;
61622   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61623   bool arg4 ;
61624   Dali::Actor *argp2 ;
61625   Dali::Actor result;
61626
61627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61628   argp2 = (Dali::Actor *)jarg2;
61629   if (!argp2) {
61630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61631     return 0;
61632   }
61633   arg2 = *argp2;
61634   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61635   arg4 = jarg4 ? true : false;
61636   {
61637     try {
61638       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61639     } catch (std::out_of_range& e) {
61640       {
61641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61642       };
61643     } catch (std::exception& e) {
61644       {
61645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61646       };
61647     } catch (...) {
61648       {
61649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61650       };
61651     }
61652   }
61653   jresult = new Dali::Actor((const Dali::Actor &)result);
61654   return jresult;
61655 }
61656
61657
61658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61659   void * jresult ;
61660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61661   Dali::Actor arg2 ;
61662   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61663   bool arg4 ;
61664   Dali::Actor *argp2 ;
61665   Dali::Actor result;
61666
61667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61668   argp2 = (Dali::Actor *)jarg2;
61669   if (!argp2) {
61670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61671     return 0;
61672   }
61673   arg2 = *argp2;
61674   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61675   arg4 = jarg4 ? true : false;
61676   {
61677     try {
61678       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61679     } catch (std::out_of_range& e) {
61680       {
61681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61682       };
61683     } catch (std::exception& e) {
61684       {
61685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61686       };
61687     } catch (...) {
61688       {
61689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61690       };
61691     }
61692   }
61693   jresult = new Dali::Actor((const Dali::Actor &)result);
61694   return jresult;
61695 }
61696
61697
61698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61700   Dali::Actor arg2 ;
61701   Dali::Actor *argp2 ;
61702
61703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61704   argp2 = (Dali::Actor *)jarg2;
61705   if (!argp2) {
61706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61707     return ;
61708   }
61709   arg2 = *argp2;
61710   {
61711     try {
61712       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61713     } catch (std::out_of_range& e) {
61714       {
61715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61716       };
61717     } catch (std::exception& e) {
61718       {
61719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61720       };
61721     } catch (...) {
61722       {
61723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61724       };
61725     }
61726   }
61727 }
61728
61729
61730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61732   Dali::Actor arg2 ;
61733   Dali::Actor *argp2 ;
61734
61735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61736   argp2 = (Dali::Actor *)jarg2;
61737   if (!argp2) {
61738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61739     return ;
61740   }
61741   arg2 = *argp2;
61742   {
61743     try {
61744       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61745     } catch (std::out_of_range& e) {
61746       {
61747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61748       };
61749     } catch (std::exception& e) {
61750       {
61751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61752       };
61753     } catch (...) {
61754       {
61755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61756       };
61757     }
61758   }
61759 }
61760
61761
61762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61763   unsigned int jresult ;
61764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61765   bool result;
61766
61767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61768   {
61769     try {
61770       result = (bool)(arg1)->OnKeyboardEnter();
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61778       };
61779     } catch (...) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61782       };
61783     }
61784   }
61785   jresult = result;
61786   return jresult;
61787 }
61788
61789
61790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61791   unsigned int jresult ;
61792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61793   bool result;
61794
61795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61796   {
61797     try {
61798       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61799     } catch (std::out_of_range& e) {
61800       {
61801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (std::exception& e) {
61804       {
61805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61806       };
61807     } catch (...) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61810       };
61811     }
61812   }
61813   jresult = result;
61814   return jresult;
61815 }
61816
61817
61818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61820   Dali::PinchGesture *arg2 = 0 ;
61821
61822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61823   arg2 = (Dali::PinchGesture *)jarg2;
61824   if (!arg2) {
61825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61826     return ;
61827   }
61828   {
61829     try {
61830       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61831     } catch (std::out_of_range& e) {
61832       {
61833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61834       };
61835     } catch (std::exception& e) {
61836       {
61837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61838       };
61839     } catch (...) {
61840       {
61841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61842       };
61843     }
61844   }
61845 }
61846
61847
61848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61850   Dali::PinchGesture *arg2 = 0 ;
61851
61852   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61853   arg2 = (Dali::PinchGesture *)jarg2;
61854   if (!arg2) {
61855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61856     return ;
61857   }
61858   {
61859     try {
61860       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61861     } catch (std::out_of_range& e) {
61862       {
61863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61864       };
61865     } catch (std::exception& e) {
61866       {
61867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61868       };
61869     } catch (...) {
61870       {
61871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61872       };
61873     }
61874   }
61875 }
61876
61877
61878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61880   Dali::PanGesture *arg2 = 0 ;
61881
61882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61883   arg2 = (Dali::PanGesture *)jarg2;
61884   if (!arg2) {
61885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61886     return ;
61887   }
61888   {
61889     try {
61890       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61891     } catch (std::out_of_range& e) {
61892       {
61893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61894       };
61895     } catch (std::exception& e) {
61896       {
61897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61902       };
61903     }
61904   }
61905 }
61906
61907
61908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61910   Dali::PanGesture *arg2 = 0 ;
61911
61912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61913   arg2 = (Dali::PanGesture *)jarg2;
61914   if (!arg2) {
61915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61916     return ;
61917   }
61918   {
61919     try {
61920       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61921     } catch (std::out_of_range& e) {
61922       {
61923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61924       };
61925     } catch (std::exception& e) {
61926       {
61927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61928       };
61929     } catch (...) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61932       };
61933     }
61934   }
61935 }
61936
61937
61938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61940   Dali::TapGesture *arg2 = 0 ;
61941
61942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61943   arg2 = (Dali::TapGesture *)jarg2;
61944   if (!arg2) {
61945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61946     return ;
61947   }
61948   {
61949     try {
61950       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61951     } catch (std::out_of_range& e) {
61952       {
61953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61954       };
61955     } catch (std::exception& e) {
61956       {
61957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61958       };
61959     } catch (...) {
61960       {
61961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61962       };
61963     }
61964   }
61965 }
61966
61967
61968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61970   Dali::TapGesture *arg2 = 0 ;
61971
61972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61973   arg2 = (Dali::TapGesture *)jarg2;
61974   if (!arg2) {
61975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61976     return ;
61977   }
61978   {
61979     try {
61980       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61981     } catch (std::out_of_range& e) {
61982       {
61983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (std::exception& e) {
61986       {
61987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61988       };
61989     } catch (...) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61992       };
61993     }
61994   }
61995 }
61996
61997
61998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
61999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62000   Dali::LongPressGesture *arg2 = 0 ;
62001
62002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62003   arg2 = (Dali::LongPressGesture *)jarg2;
62004   if (!arg2) {
62005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62006     return ;
62007   }
62008   {
62009     try {
62010       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62011     } catch (std::out_of_range& e) {
62012       {
62013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62014       };
62015     } catch (std::exception& e) {
62016       {
62017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62018       };
62019     } catch (...) {
62020       {
62021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62022       };
62023     }
62024   }
62025 }
62026
62027
62028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62030   Dali::LongPressGesture *arg2 = 0 ;
62031
62032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62033   arg2 = (Dali::LongPressGesture *)jarg2;
62034   if (!arg2) {
62035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62036     return ;
62037   }
62038   {
62039     try {
62040       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62041     } catch (std::out_of_range& e) {
62042       {
62043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62044       };
62045     } catch (std::exception& e) {
62046       {
62047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62048       };
62049     } catch (...) {
62050       {
62051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62052       };
62053     }
62054   }
62055 }
62056
62057
62058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62060   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62061   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62062
62063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62064   arg2 = (Dali::SlotObserver *)jarg2;
62065   arg3 = (Dali::CallbackBase *)jarg3;
62066   {
62067     try {
62068       (arg1)->SignalConnected(arg2,arg3);
62069     } catch (std::out_of_range& e) {
62070       {
62071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62072       };
62073     } catch (std::exception& e) {
62074       {
62075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62076       };
62077     } catch (...) {
62078       {
62079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62080       };
62081     }
62082   }
62083 }
62084
62085
62086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62090
62091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62092   arg2 = (Dali::SlotObserver *)jarg2;
62093   arg3 = (Dali::CallbackBase *)jarg3;
62094   {
62095     try {
62096       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62097     } catch (std::out_of_range& e) {
62098       {
62099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62100       };
62101     } catch (std::exception& e) {
62102       {
62103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62104       };
62105     } catch (...) {
62106       {
62107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62108       };
62109     }
62110   }
62111 }
62112
62113
62114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62116   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62117   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62118
62119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62120   arg2 = (Dali::SlotObserver *)jarg2;
62121   arg3 = (Dali::CallbackBase *)jarg3;
62122   {
62123     try {
62124       (arg1)->SignalDisconnected(arg2,arg3);
62125     } catch (std::out_of_range& e) {
62126       {
62127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62128       };
62129     } catch (std::exception& e) {
62130       {
62131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62132       };
62133     } catch (...) {
62134       {
62135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62136       };
62137     }
62138   }
62139 }
62140
62141
62142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62144   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62145   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62146
62147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62148   arg2 = (Dali::SlotObserver *)jarg2;
62149   arg3 = (Dali::CallbackBase *)jarg3;
62150   {
62151     try {
62152       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62153     } catch (std::out_of_range& e) {
62154       {
62155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62156       };
62157     } catch (std::exception& e) {
62158       {
62159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62160       };
62161     } catch (...) {
62162       {
62163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62164       };
62165     }
62166   }
62167 }
62168
62169
62170 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) {
62171   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62172   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62173   if (director) {
62174     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);
62175   }
62176 }
62177
62178
62179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62180   void * jresult ;
62181   Dali::Toolkit::Control *arg1 = 0 ;
62182   Dali::Toolkit::Internal::Control *result = 0 ;
62183
62184   arg1 = (Dali::Toolkit::Control *)jarg1;
62185   if (!arg1) {
62186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62187     return 0;
62188   }
62189   {
62190     try {
62191       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62192     } catch (std::out_of_range& e) {
62193       {
62194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62195       };
62196     } catch (std::exception& e) {
62197       {
62198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62199       };
62200     } catch (...) {
62201       {
62202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62203       };
62204     }
62205   }
62206   jresult = (void *)result;
62207   return jresult;
62208 }
62209
62210
62211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62212   int jresult ;
62213   int result;
62214
62215   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62216   jresult = (int)result;
62217   return jresult;
62218 }
62219
62220
62221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62222   int jresult ;
62223   int result;
62224
62225   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62226   jresult = (int)result;
62227   return jresult;
62228 }
62229
62230
62231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62232   int jresult ;
62233   int result;
62234
62235   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62236   jresult = (int)result;
62237   return jresult;
62238 }
62239
62240
62241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62242   int jresult ;
62243   int result;
62244
62245   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62246   jresult = (int)result;
62247   return jresult;
62248 }
62249
62250
62251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62252   int jresult ;
62253   int result;
62254
62255   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62256   jresult = (int)result;
62257   return jresult;
62258 }
62259
62260
62261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62262   void * jresult ;
62263   Dali::Toolkit::Control::Property *result = 0 ;
62264
62265   {
62266     try {
62267       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62268     } catch (std::out_of_range& e) {
62269       {
62270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62271       };
62272     } catch (std::exception& e) {
62273       {
62274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62275       };
62276     } catch (...) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62279       };
62280     }
62281   }
62282   jresult = (void *)result;
62283   return jresult;
62284 }
62285
62286
62287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62288   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62289
62290   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62291   {
62292     try {
62293       delete arg1;
62294     } catch (std::out_of_range& e) {
62295       {
62296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62297       };
62298     } catch (std::exception& e) {
62299       {
62300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62301       };
62302     } catch (...) {
62303       {
62304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62305       };
62306     }
62307   }
62308 }
62309
62310
62311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62312   void * jresult ;
62313   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62314
62315   {
62316     try {
62317       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (...) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62329       };
62330     }
62331   }
62332   jresult = (void *)result;
62333   return jresult;
62334 }
62335
62336
62337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62338   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62339
62340   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62341   {
62342     try {
62343       delete arg1;
62344     } catch (std::out_of_range& e) {
62345       {
62346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62347       };
62348     } catch (std::exception& e) {
62349       {
62350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62351       };
62352     } catch (...) {
62353       {
62354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62355       };
62356     }
62357   }
62358 }
62359
62360
62361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62362   void * jresult ;
62363   Dali::Toolkit::Control result;
62364
62365   {
62366     try {
62367       result = Dali::Toolkit::Control::New();
62368     } catch (std::out_of_range& e) {
62369       {
62370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62371       };
62372     } catch (std::exception& e) {
62373       {
62374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62375       };
62376     } catch (...) {
62377       {
62378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62379       };
62380     }
62381   }
62382   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62383   return jresult;
62384 }
62385
62386
62387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62388   void * jresult ;
62389   Dali::Toolkit::Control *result = 0 ;
62390
62391   {
62392     try {
62393       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (...) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62405       };
62406     }
62407   }
62408   jresult = (void *)result;
62409   return jresult;
62410 }
62411
62412
62413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62414   void * jresult ;
62415   Dali::Toolkit::Control *arg1 = 0 ;
62416   Dali::Toolkit::Control *result = 0 ;
62417
62418   arg1 = (Dali::Toolkit::Control *)jarg1;
62419   if (!arg1) {
62420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62421     return 0;
62422   }
62423   {
62424     try {
62425       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (...) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62437       };
62438     }
62439   }
62440   jresult = (void *)result;
62441   return jresult;
62442 }
62443
62444
62445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62446   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62447
62448   arg1 = (Dali::Toolkit::Control *)jarg1;
62449   {
62450     try {
62451       delete arg1;
62452     } catch (std::out_of_range& e) {
62453       {
62454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (std::exception& e) {
62457       {
62458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62463       };
62464     }
62465   }
62466 }
62467
62468
62469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62470   void * jresult ;
62471   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62472   Dali::Toolkit::Control *arg2 = 0 ;
62473   Dali::Toolkit::Control *result = 0 ;
62474
62475   arg1 = (Dali::Toolkit::Control *)jarg1;
62476   arg2 = (Dali::Toolkit::Control *)jarg2;
62477   if (!arg2) {
62478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62479     return 0;
62480   }
62481   {
62482     try {
62483       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62484     } catch (std::out_of_range& e) {
62485       {
62486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62487       };
62488     } catch (std::exception& e) {
62489       {
62490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62491       };
62492     } catch (...) {
62493       {
62494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62495       };
62496     }
62497   }
62498   jresult = (void *)result;
62499   return jresult;
62500 }
62501
62502
62503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62504   void * jresult ;
62505   Dali::BaseHandle arg1 ;
62506   Dali::BaseHandle *argp1 ;
62507   Dali::Toolkit::Control result;
62508
62509   argp1 = (Dali::BaseHandle *)jarg1;
62510   if (!argp1) {
62511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62512     return 0;
62513   }
62514   arg1 = *argp1;
62515   {
62516     try {
62517       result = Dali::Toolkit::Control::DownCast(arg1);
62518     } catch (std::out_of_range& e) {
62519       {
62520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62521       };
62522     } catch (std::exception& e) {
62523       {
62524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62525       };
62526     } catch (...) {
62527       {
62528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62529       };
62530     }
62531   }
62532   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62533   return jresult;
62534 }
62535
62536
62537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62538   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62539
62540   arg1 = (Dali::Toolkit::Control *)jarg1;
62541   {
62542     try {
62543       (arg1)->SetKeyInputFocus();
62544     } catch (std::out_of_range& e) {
62545       {
62546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62547       };
62548     } catch (std::exception& e) {
62549       {
62550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62551       };
62552     } catch (...) {
62553       {
62554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62555       };
62556     }
62557   }
62558 }
62559
62560
62561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62562   unsigned int jresult ;
62563   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62564   bool result;
62565
62566   arg1 = (Dali::Toolkit::Control *)jarg1;
62567   {
62568     try {
62569       result = (bool)(arg1)->HasKeyInputFocus();
62570     } catch (std::out_of_range& e) {
62571       {
62572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (std::exception& e) {
62575       {
62576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (...) {
62579       {
62580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62581       };
62582     }
62583   }
62584   jresult = result;
62585   return jresult;
62586 }
62587
62588
62589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62590   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62591
62592   arg1 = (Dali::Toolkit::Control *)jarg1;
62593   {
62594     try {
62595       (arg1)->ClearKeyInputFocus();
62596     } catch (std::out_of_range& e) {
62597       {
62598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62599       };
62600     } catch (std::exception& e) {
62601       {
62602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62603       };
62604     } catch (...) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62607       };
62608     }
62609   }
62610 }
62611
62612
62613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62614   void * jresult ;
62615   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62616   Dali::PinchGestureDetector result;
62617
62618   arg1 = (Dali::Toolkit::Control *)jarg1;
62619   {
62620     try {
62621       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62622     } catch (std::out_of_range& e) {
62623       {
62624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (std::exception& e) {
62627       {
62628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62633       };
62634     }
62635   }
62636   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62637   return jresult;
62638 }
62639
62640
62641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62642   void * jresult ;
62643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62644   Dali::PanGestureDetector result;
62645
62646   arg1 = (Dali::Toolkit::Control *)jarg1;
62647   {
62648     try {
62649       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62650     } catch (std::out_of_range& e) {
62651       {
62652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62653       };
62654     } catch (std::exception& e) {
62655       {
62656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (...) {
62659       {
62660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62661       };
62662     }
62663   }
62664   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62665   return jresult;
62666 }
62667
62668
62669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62670   void * jresult ;
62671   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62672   Dali::TapGestureDetector result;
62673
62674   arg1 = (Dali::Toolkit::Control *)jarg1;
62675   {
62676     try {
62677       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62678     } catch (std::out_of_range& e) {
62679       {
62680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62681       };
62682     } catch (std::exception& e) {
62683       {
62684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (...) {
62687       {
62688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62689       };
62690     }
62691   }
62692   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62693   return jresult;
62694 }
62695
62696
62697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62698   void * jresult ;
62699   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62700   Dali::LongPressGestureDetector result;
62701
62702   arg1 = (Dali::Toolkit::Control *)jarg1;
62703   {
62704     try {
62705       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62706     } catch (std::out_of_range& e) {
62707       {
62708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62709       };
62710     } catch (std::exception& e) {
62711       {
62712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62713       };
62714     } catch (...) {
62715       {
62716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62717       };
62718     }
62719   }
62720   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62721   return jresult;
62722 }
62723
62724
62725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62726   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62727   std::string *arg2 = 0 ;
62728
62729   arg1 = (Dali::Toolkit::Control *)jarg1;
62730   if (!jarg2) {
62731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62732     return ;
62733   }
62734   std::string arg2_str(jarg2);
62735   arg2 = &arg2_str;
62736   {
62737     try {
62738       (arg1)->SetStyleName((std::string const &)*arg2);
62739     } catch (std::out_of_range& e) {
62740       {
62741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62742       };
62743     } catch (std::exception& e) {
62744       {
62745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62746       };
62747     } catch (...) {
62748       {
62749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62750       };
62751     }
62752   }
62753
62754   //argout typemap for const std::string&
62755
62756 }
62757
62758
62759 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62760   char * jresult ;
62761   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62762   std::string *result = 0 ;
62763
62764   arg1 = (Dali::Toolkit::Control *)jarg1;
62765   {
62766     try {
62767       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62768     } catch (std::out_of_range& e) {
62769       {
62770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62771       };
62772     } catch (std::exception& e) {
62773       {
62774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62779       };
62780     }
62781   }
62782   jresult = SWIG_csharp_string_callback(result->c_str());
62783   return jresult;
62784 }
62785
62786
62787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62789   Dali::Vector4 *arg2 = 0 ;
62790
62791   arg1 = (Dali::Toolkit::Control *)jarg1;
62792   arg2 = (Dali::Vector4 *)jarg2;
62793   if (!arg2) {
62794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62795     return ;
62796   }
62797   {
62798     try {
62799       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62800     } catch (std::out_of_range& e) {
62801       {
62802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62803       };
62804     } catch (std::exception& e) {
62805       {
62806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62807       };
62808     } catch (...) {
62809       {
62810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62811       };
62812     }
62813   }
62814 }
62815
62816
62817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62818   void * jresult ;
62819   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62820   Dali::Vector4 result;
62821
62822   arg1 = (Dali::Toolkit::Control *)jarg1;
62823   {
62824     try {
62825       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62826     } catch (std::out_of_range& e) {
62827       {
62828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (std::exception& e) {
62831       {
62832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (...) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62837       };
62838     }
62839   }
62840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62841   return jresult;
62842 }
62843
62844
62845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62846   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62847   Dali::Image arg2 ;
62848   Dali::Image *argp2 ;
62849
62850   arg1 = (Dali::Toolkit::Control *)jarg1;
62851   argp2 = (Dali::Image *)jarg2;
62852   if (!argp2) {
62853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62854     return ;
62855   }
62856   arg2 = *argp2;
62857   {
62858     try {
62859       (arg1)->SetBackgroundImage(arg2);
62860     } catch (std::out_of_range& e) {
62861       {
62862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62863       };
62864     } catch (std::exception& e) {
62865       {
62866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62867       };
62868     } catch (...) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62871       };
62872     }
62873   }
62874 }
62875
62876
62877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62878   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62879
62880   arg1 = (Dali::Toolkit::Control *)jarg1;
62881   {
62882     try {
62883       (arg1)->ClearBackground();
62884     } catch (std::out_of_range& e) {
62885       {
62886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62887       };
62888     } catch (std::exception& e) {
62889       {
62890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62891       };
62892     } catch (...) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62895       };
62896     }
62897   }
62898 }
62899
62900
62901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62902   void * jresult ;
62903   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62904   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62905
62906   arg1 = (Dali::Toolkit::Control *)jarg1;
62907   {
62908     try {
62909       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62910     } catch (std::out_of_range& e) {
62911       {
62912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62913       };
62914     } catch (std::exception& e) {
62915       {
62916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62917       };
62918     } catch (...) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62921       };
62922     }
62923   }
62924   jresult = (void *)result;
62925   return jresult;
62926 }
62927
62928
62929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62930   void * jresult ;
62931   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62932   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62933
62934   arg1 = (Dali::Toolkit::Control *)jarg1;
62935   {
62936     try {
62937       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62949       };
62950     }
62951   }
62952   jresult = (void *)result;
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62958   void * jresult ;
62959   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62960   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62961
62962   arg1 = (Dali::Toolkit::Control *)jarg1;
62963   {
62964     try {
62965       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (...) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62977       };
62978     }
62979   }
62980   jresult = (void *)result;
62981   return jresult;
62982 }
62983
62984
62985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62986   void * jresult ;
62987   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62988   Dali::Toolkit::Control *result = 0 ;
62989
62990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62991   if (!arg1) {
62992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
62993     return 0;
62994   }
62995   {
62996     try {
62997       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63005       };
63006     } catch (...) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63009       };
63010     }
63011   }
63012   jresult = (void *)result;
63013   return jresult;
63014 }
63015
63016
63017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63018   void * jresult ;
63019   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63020
63021   {
63022     try {
63023       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63024     } catch (std::out_of_range& e) {
63025       {
63026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63027       };
63028     } catch (std::exception& e) {
63029       {
63030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63031       };
63032     } catch (...) {
63033       {
63034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63035       };
63036     }
63037   }
63038   jresult = (void *)result;
63039   return jresult;
63040 }
63041
63042
63043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63044   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63045
63046   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63047   {
63048     try {
63049       delete arg1;
63050     } catch (std::out_of_range& e) {
63051       {
63052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63053       };
63054     } catch (std::exception& e) {
63055       {
63056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63057       };
63058     } catch (...) {
63059       {
63060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63061       };
63062     }
63063   }
63064 }
63065
63066
63067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63068   void * jresult ;
63069   Dali::Toolkit::KeyInputFocusManager result;
63070
63071   {
63072     try {
63073       result = Dali::Toolkit::KeyInputFocusManager::Get();
63074     } catch (std::out_of_range& e) {
63075       {
63076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63077       };
63078     } catch (std::exception& e) {
63079       {
63080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (...) {
63083       {
63084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63085       };
63086     }
63087   }
63088   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63089   return jresult;
63090 }
63091
63092
63093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63094   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63095   Dali::Toolkit::Control arg2 ;
63096   Dali::Toolkit::Control *argp2 ;
63097
63098   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63099   argp2 = (Dali::Toolkit::Control *)jarg2;
63100   if (!argp2) {
63101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63102     return ;
63103   }
63104   arg2 = *argp2;
63105   {
63106     try {
63107       (arg1)->SetFocus(arg2);
63108     } catch (std::out_of_range& e) {
63109       {
63110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63111       };
63112     } catch (std::exception& e) {
63113       {
63114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63115       };
63116     } catch (...) {
63117       {
63118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63119       };
63120     }
63121   }
63122 }
63123
63124
63125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63126   void * jresult ;
63127   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63128   Dali::Toolkit::Control result;
63129
63130   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63131   {
63132     try {
63133       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63134     } catch (std::out_of_range& e) {
63135       {
63136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63137       };
63138     } catch (std::exception& e) {
63139       {
63140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63141       };
63142     } catch (...) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63145       };
63146     }
63147   }
63148   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63149   return jresult;
63150 }
63151
63152
63153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63154   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63155   Dali::Toolkit::Control arg2 ;
63156   Dali::Toolkit::Control *argp2 ;
63157
63158   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63159   argp2 = (Dali::Toolkit::Control *)jarg2;
63160   if (!argp2) {
63161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63162     return ;
63163   }
63164   arg2 = *argp2;
63165   {
63166     try {
63167       (arg1)->RemoveFocus(arg2);
63168     } catch (std::out_of_range& e) {
63169       {
63170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63171       };
63172     } catch (std::exception& e) {
63173       {
63174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63175       };
63176     } catch (...) {
63177       {
63178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63179       };
63180     }
63181   }
63182 }
63183
63184
63185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63186   void * jresult ;
63187   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63188   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63189
63190   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63191   {
63192     try {
63193       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63194     } catch (std::out_of_range& e) {
63195       {
63196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (std::exception& e) {
63199       {
63200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208   jresult = (void *)result;
63209   return jresult;
63210 }
63211
63212
63213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63214   void * jresult ;
63215   Dali::Toolkit::Alignment::Padding *result = 0 ;
63216
63217   {
63218     try {
63219       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63220     } catch (std::out_of_range& e) {
63221       {
63222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63223       };
63224     } catch (std::exception& e) {
63225       {
63226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63231       };
63232     }
63233   }
63234   jresult = (void *)result;
63235   return jresult;
63236 }
63237
63238
63239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63240   void * jresult ;
63241   float arg1 ;
63242   float arg2 ;
63243   float arg3 ;
63244   float arg4 ;
63245   Dali::Toolkit::Alignment::Padding *result = 0 ;
63246
63247   arg1 = (float)jarg1;
63248   arg2 = (float)jarg2;
63249   arg3 = (float)jarg3;
63250   arg4 = (float)jarg4;
63251   {
63252     try {
63253       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63254     } catch (std::out_of_range& e) {
63255       {
63256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63257       };
63258     } catch (std::exception& e) {
63259       {
63260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63261       };
63262     } catch (...) {
63263       {
63264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63265       };
63266     }
63267   }
63268   jresult = (void *)result;
63269   return jresult;
63270 }
63271
63272
63273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63274   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63275   float arg2 ;
63276
63277   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63278   arg2 = (float)jarg2;
63279   if (arg1) (arg1)->left = arg2;
63280 }
63281
63282
63283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63284   float jresult ;
63285   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63286   float result;
63287
63288   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63289   result = (float) ((arg1)->left);
63290   jresult = result;
63291   return jresult;
63292 }
63293
63294
63295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63296   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63297   float arg2 ;
63298
63299   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63300   arg2 = (float)jarg2;
63301   if (arg1) (arg1)->right = arg2;
63302 }
63303
63304
63305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63306   float jresult ;
63307   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63308   float result;
63309
63310   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63311   result = (float) ((arg1)->right);
63312   jresult = result;
63313   return jresult;
63314 }
63315
63316
63317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63318   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63319   float arg2 ;
63320
63321   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63322   arg2 = (float)jarg2;
63323   if (arg1) (arg1)->top = arg2;
63324 }
63325
63326
63327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63328   float jresult ;
63329   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63330   float result;
63331
63332   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63333   result = (float) ((arg1)->top);
63334   jresult = result;
63335   return jresult;
63336 }
63337
63338
63339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63340   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63341   float arg2 ;
63342
63343   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63344   arg2 = (float)jarg2;
63345   if (arg1) (arg1)->bottom = arg2;
63346 }
63347
63348
63349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63350   float jresult ;
63351   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63352   float result;
63353
63354   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63355   result = (float) ((arg1)->bottom);
63356   jresult = result;
63357   return jresult;
63358 }
63359
63360
63361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63362   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63363
63364   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63365   {
63366     try {
63367       delete arg1;
63368     } catch (std::out_of_range& e) {
63369       {
63370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63371       };
63372     } catch (std::exception& e) {
63373       {
63374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63375       };
63376     } catch (...) {
63377       {
63378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63379       };
63380     }
63381   }
63382 }
63383
63384
63385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63386   void * jresult ;
63387   Dali::Toolkit::Alignment *result = 0 ;
63388
63389   {
63390     try {
63391       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63392     } catch (std::out_of_range& e) {
63393       {
63394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63395       };
63396     } catch (std::exception& e) {
63397       {
63398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63399       };
63400     } catch (...) {
63401       {
63402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63403       };
63404     }
63405   }
63406   jresult = (void *)result;
63407   return jresult;
63408 }
63409
63410
63411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63412   void * jresult ;
63413   Dali::Toolkit::Alignment::Type arg1 ;
63414   Dali::Toolkit::Alignment::Type arg2 ;
63415   Dali::Toolkit::Alignment result;
63416
63417   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63418   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63419   {
63420     try {
63421       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63422     } catch (std::out_of_range& e) {
63423       {
63424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63425       };
63426     } catch (std::exception& e) {
63427       {
63428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63429       };
63430     } catch (...) {
63431       {
63432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63433       };
63434     }
63435   }
63436   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63437   return jresult;
63438 }
63439
63440
63441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63442   void * jresult ;
63443   Dali::Toolkit::Alignment::Type arg1 ;
63444   Dali::Toolkit::Alignment result;
63445
63446   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63447   {
63448     try {
63449       result = Dali::Toolkit::Alignment::New(arg1);
63450     } catch (std::out_of_range& e) {
63451       {
63452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63453       };
63454     } catch (std::exception& e) {
63455       {
63456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63457       };
63458     } catch (...) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63461       };
63462     }
63463   }
63464   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63465   return jresult;
63466 }
63467
63468
63469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63470   void * jresult ;
63471   Dali::Toolkit::Alignment result;
63472
63473   {
63474     try {
63475       result = Dali::Toolkit::Alignment::New();
63476     } catch (std::out_of_range& e) {
63477       {
63478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63479       };
63480     } catch (std::exception& e) {
63481       {
63482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63483       };
63484     } catch (...) {
63485       {
63486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63487       };
63488     }
63489   }
63490   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63491   return jresult;
63492 }
63493
63494
63495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63496   void * jresult ;
63497   Dali::Toolkit::Alignment *arg1 = 0 ;
63498   Dali::Toolkit::Alignment *result = 0 ;
63499
63500   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63501   if (!arg1) {
63502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63503     return 0;
63504   }
63505   {
63506     try {
63507       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63508     } catch (std::out_of_range& e) {
63509       {
63510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63511       };
63512     } catch (std::exception& e) {
63513       {
63514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63519       };
63520     }
63521   }
63522   jresult = (void *)result;
63523   return jresult;
63524 }
63525
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63528   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63529
63530   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63531   {
63532     try {
63533       delete arg1;
63534     } catch (std::out_of_range& e) {
63535       {
63536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63537       };
63538     } catch (std::exception& e) {
63539       {
63540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (...) {
63543       {
63544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63545       };
63546     }
63547   }
63548 }
63549
63550
63551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63552   void * jresult ;
63553   Dali::BaseHandle arg1 ;
63554   Dali::BaseHandle *argp1 ;
63555   Dali::Toolkit::Alignment result;
63556
63557   argp1 = (Dali::BaseHandle *)jarg1;
63558   if (!argp1) {
63559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63560     return 0;
63561   }
63562   arg1 = *argp1;
63563   {
63564     try {
63565       result = Dali::Toolkit::Alignment::DownCast(arg1);
63566     } catch (std::out_of_range& e) {
63567       {
63568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63569       };
63570     } catch (std::exception& e) {
63571       {
63572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63573       };
63574     } catch (...) {
63575       {
63576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63577       };
63578     }
63579   }
63580   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63581   return jresult;
63582 }
63583
63584
63585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63586   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63587   Dali::Toolkit::Alignment::Type arg2 ;
63588
63589   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63590   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63591   {
63592     try {
63593       (arg1)->SetAlignmentType(arg2);
63594     } catch (std::out_of_range& e) {
63595       {
63596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63597       };
63598     } catch (std::exception& e) {
63599       {
63600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63601       };
63602     } catch (...) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63605       };
63606     }
63607   }
63608 }
63609
63610
63611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63612   int jresult ;
63613   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63614   Dali::Toolkit::Alignment::Type result;
63615
63616   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63617   {
63618     try {
63619       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63620     } catch (std::out_of_range& e) {
63621       {
63622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (std::exception& e) {
63625       {
63626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63627       };
63628     } catch (...) {
63629       {
63630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63631       };
63632     }
63633   }
63634   jresult = (int)result;
63635   return jresult;
63636 }
63637
63638
63639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63640   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63641   Dali::Toolkit::Alignment::Scaling arg2 ;
63642
63643   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63644   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63645   {
63646     try {
63647       (arg1)->SetScaling(arg2);
63648     } catch (std::out_of_range& e) {
63649       {
63650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63651       };
63652     } catch (std::exception& e) {
63653       {
63654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63655       };
63656     } catch (...) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63659       };
63660     }
63661   }
63662 }
63663
63664
63665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63666   int jresult ;
63667   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63668   Dali::Toolkit::Alignment::Scaling result;
63669
63670   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63671   {
63672     try {
63673       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63674     } catch (std::out_of_range& e) {
63675       {
63676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63677       };
63678     } catch (std::exception& e) {
63679       {
63680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63681       };
63682     } catch (...) {
63683       {
63684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63685       };
63686     }
63687   }
63688   jresult = (int)result;
63689   return jresult;
63690 }
63691
63692
63693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63694   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63695   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63696
63697   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63698   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63699   if (!arg2) {
63700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63701     return ;
63702   }
63703   {
63704     try {
63705       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63706     } catch (std::out_of_range& e) {
63707       {
63708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63709       };
63710     } catch (std::exception& e) {
63711       {
63712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63713       };
63714     } catch (...) {
63715       {
63716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63717       };
63718     }
63719   }
63720 }
63721
63722
63723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63724   void * jresult ;
63725   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63726   Dali::Toolkit::Alignment::Padding *result = 0 ;
63727
63728   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63729   {
63730     try {
63731       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63732     } catch (std::out_of_range& e) {
63733       {
63734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63735       };
63736     } catch (std::exception& e) {
63737       {
63738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63739       };
63740     } catch (...) {
63741       {
63742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63743       };
63744     }
63745   }
63746   jresult = (void *)result;
63747   return jresult;
63748 }
63749
63750
63751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63752   void * jresult ;
63753   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63754   Dali::Toolkit::Alignment *arg2 = 0 ;
63755   Dali::Toolkit::Alignment *result = 0 ;
63756
63757   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63758   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63759   if (!arg2) {
63760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63761     return 0;
63762   }
63763   {
63764     try {
63765       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63766     } catch (std::out_of_range& e) {
63767       {
63768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63769       };
63770     } catch (std::exception& e) {
63771       {
63772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63773       };
63774     } catch (...) {
63775       {
63776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63777       };
63778     }
63779   }
63780   jresult = (void *)result;
63781   return jresult;
63782 }
63783
63784
63785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63786   int jresult ;
63787   int result;
63788
63789   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63790   jresult = (int)result;
63791   return jresult;
63792 }
63793
63794
63795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63796   int jresult ;
63797   int result;
63798
63799   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63800   jresult = (int)result;
63801   return jresult;
63802 }
63803
63804
63805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63806   int jresult ;
63807   int result;
63808
63809   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63810   jresult = (int)result;
63811   return jresult;
63812 }
63813
63814
63815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63816   int jresult ;
63817   int result;
63818
63819   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63820   jresult = (int)result;
63821   return jresult;
63822 }
63823
63824
63825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63826   int jresult ;
63827   int result;
63828
63829   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63830   jresult = (int)result;
63831   return jresult;
63832 }
63833
63834
63835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63836   int jresult ;
63837   int result;
63838
63839   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63840   jresult = (int)result;
63841   return jresult;
63842 }
63843
63844
63845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63846   int jresult ;
63847   int result;
63848
63849   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63850   jresult = (int)result;
63851   return jresult;
63852 }
63853
63854
63855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63856   int jresult ;
63857   int result;
63858
63859   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63860   jresult = (int)result;
63861   return jresult;
63862 }
63863
63864
63865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63866   int jresult ;
63867   int result;
63868
63869   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63870   jresult = (int)result;
63871   return jresult;
63872 }
63873
63874
63875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63876   int jresult ;
63877   int result;
63878
63879   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63880   jresult = (int)result;
63881   return jresult;
63882 }
63883
63884
63885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63886   int jresult ;
63887   int result;
63888
63889   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63890   jresult = (int)result;
63891   return jresult;
63892 }
63893
63894
63895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63896   int jresult ;
63897   int result;
63898
63899   result = (int)Dali::Toolkit::Button::Property::LABEL;
63900   jresult = (int)result;
63901   return jresult;
63902 }
63903
63904
63905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63906   int jresult ;
63907   int result;
63908
63909   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63910   jresult = (int)result;
63911   return jresult;
63912 }
63913
63914
63915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63916   void * jresult ;
63917   Dali::Toolkit::Button::Property *result = 0 ;
63918
63919   {
63920     try {
63921       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63922     } catch (std::out_of_range& e) {
63923       {
63924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63925       };
63926     } catch (std::exception& e) {
63927       {
63928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63929       };
63930     } catch (...) {
63931       {
63932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63933       };
63934     }
63935   }
63936   jresult = (void *)result;
63937   return jresult;
63938 }
63939
63940
63941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63942   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63943
63944   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63945   {
63946     try {
63947       delete arg1;
63948     } catch (std::out_of_range& e) {
63949       {
63950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63951       };
63952     } catch (std::exception& e) {
63953       {
63954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63955       };
63956     } catch (...) {
63957       {
63958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63959       };
63960     }
63961   }
63962 }
63963
63964
63965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63966   void * jresult ;
63967   Dali::Toolkit::Button *result = 0 ;
63968
63969   {
63970     try {
63971       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63972     } catch (std::out_of_range& e) {
63973       {
63974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63975       };
63976     } catch (std::exception& e) {
63977       {
63978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63979       };
63980     } catch (...) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63983       };
63984     }
63985   }
63986   jresult = (void *)result;
63987   return jresult;
63988 }
63989
63990
63991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
63992   void * jresult ;
63993   Dali::Toolkit::Button *arg1 = 0 ;
63994   Dali::Toolkit::Button *result = 0 ;
63995
63996   arg1 = (Dali::Toolkit::Button *)jarg1;
63997   if (!arg1) {
63998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63999     return 0;
64000   }
64001   {
64002     try {
64003       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64004     } catch (std::out_of_range& e) {
64005       {
64006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64007       };
64008     } catch (std::exception& e) {
64009       {
64010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64011       };
64012     } catch (...) {
64013       {
64014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64015       };
64016     }
64017   }
64018   jresult = (void *)result;
64019   return jresult;
64020 }
64021
64022
64023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64024   void * jresult ;
64025   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64026   Dali::Toolkit::Button *arg2 = 0 ;
64027   Dali::Toolkit::Button *result = 0 ;
64028
64029   arg1 = (Dali::Toolkit::Button *)jarg1;
64030   arg2 = (Dali::Toolkit::Button *)jarg2;
64031   if (!arg2) {
64032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64033     return 0;
64034   }
64035   {
64036     try {
64037       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64038     } catch (std::out_of_range& e) {
64039       {
64040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64041       };
64042     } catch (std::exception& e) {
64043       {
64044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64045       };
64046     } catch (...) {
64047       {
64048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64049       };
64050     }
64051   }
64052   jresult = (void *)result;
64053   return jresult;
64054 }
64055
64056
64057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64058   void * jresult ;
64059   Dali::BaseHandle arg1 ;
64060   Dali::BaseHandle *argp1 ;
64061   Dali::Toolkit::Button result;
64062
64063   argp1 = (Dali::BaseHandle *)jarg1;
64064   if (!argp1) {
64065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64066     return 0;
64067   }
64068   arg1 = *argp1;
64069   {
64070     try {
64071       result = Dali::Toolkit::Button::DownCast(arg1);
64072     } catch (std::out_of_range& e) {
64073       {
64074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64075       };
64076     } catch (std::exception& e) {
64077       {
64078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64079       };
64080     } catch (...) {
64081       {
64082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64083       };
64084     }
64085   }
64086   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64087   return jresult;
64088 }
64089
64090
64091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64092   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64093
64094   arg1 = (Dali::Toolkit::Button *)jarg1;
64095   {
64096     try {
64097       delete arg1;
64098     } catch (std::out_of_range& e) {
64099       {
64100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64101       };
64102     } catch (std::exception& e) {
64103       {
64104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64105       };
64106     } catch (...) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64109       };
64110     }
64111   }
64112 }
64113
64114
64115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64116   unsigned int jresult ;
64117   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64118   bool result;
64119
64120   arg1 = (Dali::Toolkit::Button *)jarg1;
64121   {
64122     try {
64123       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64124     } catch (std::out_of_range& e) {
64125       {
64126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (std::exception& e) {
64129       {
64130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64135       };
64136     }
64137   }
64138   jresult = result;
64139   return jresult;
64140 }
64141
64142
64143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64144   unsigned int jresult ;
64145   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64146   bool result;
64147
64148   arg1 = (Dali::Toolkit::Button *)jarg1;
64149   {
64150     try {
64151       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64152     } catch (std::out_of_range& e) {
64153       {
64154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64155       };
64156     } catch (std::exception& e) {
64157       {
64158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64159       };
64160     } catch (...) {
64161       {
64162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64163       };
64164     }
64165   }
64166   jresult = result;
64167   return jresult;
64168 }
64169
64170
64171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64172   float jresult ;
64173   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64174   float result;
64175
64176   arg1 = (Dali::Toolkit::Button *)jarg1;
64177   {
64178     try {
64179       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64180     } catch (std::out_of_range& e) {
64181       {
64182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64183       };
64184     } catch (std::exception& e) {
64185       {
64186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64187       };
64188     } catch (...) {
64189       {
64190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64191       };
64192     }
64193   }
64194   jresult = result;
64195   return jresult;
64196 }
64197
64198
64199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64200   float jresult ;
64201   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64202   float result;
64203
64204   arg1 = (Dali::Toolkit::Button *)jarg1;
64205   {
64206     try {
64207       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64208     } catch (std::out_of_range& e) {
64209       {
64210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64211       };
64212     } catch (std::exception& e) {
64213       {
64214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64215       };
64216     } catch (...) {
64217       {
64218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64219       };
64220     }
64221   }
64222   jresult = result;
64223   return jresult;
64224 }
64225
64226
64227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64228   unsigned int jresult ;
64229   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64230   bool result;
64231
64232   arg1 = (Dali::Toolkit::Button *)jarg1;
64233   {
64234     try {
64235       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64243       };
64244     } catch (...) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64247       };
64248     }
64249   }
64250   jresult = result;
64251   return jresult;
64252 }
64253
64254
64255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64256   unsigned int jresult ;
64257   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64258   bool result;
64259
64260   arg1 = (Dali::Toolkit::Button *)jarg1;
64261   {
64262     try {
64263       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64264     } catch (std::out_of_range& e) {
64265       {
64266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64267       };
64268     } catch (std::exception& e) {
64269       {
64270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64271       };
64272     } catch (...) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64275       };
64276     }
64277   }
64278   jresult = result;
64279   return jresult;
64280 }
64281
64282
64283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64284   float jresult ;
64285   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64286   float result;
64287
64288   arg1 = (Dali::Toolkit::Button *)jarg1;
64289   {
64290     try {
64291       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64292     } catch (std::out_of_range& e) {
64293       {
64294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64295       };
64296     } catch (std::exception& e) {
64297       {
64298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64299       };
64300     } catch (...) {
64301       {
64302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64303       };
64304     }
64305   }
64306   jresult = result;
64307   return jresult;
64308 }
64309
64310
64311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64312   char * jresult ;
64313   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64314   std::string result;
64315
64316   arg1 = (Dali::Toolkit::Button *)jarg1;
64317   {
64318     try {
64319       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64320     } catch (std::out_of_range& e) {
64321       {
64322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64323       };
64324     } catch (std::exception& e) {
64325       {
64326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64327       };
64328     } catch (...) {
64329       {
64330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64331       };
64332     }
64333   }
64334   jresult = SWIG_csharp_string_callback((&result)->c_str());
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64340   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64341   Dali::Actor arg2 ;
64342   Dali::Actor *argp2 ;
64343
64344   arg1 = (Dali::Toolkit::Button *)jarg1;
64345   argp2 = (Dali::Actor *)jarg2;
64346   if (!argp2) {
64347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64348     return ;
64349   }
64350   arg2 = *argp2;
64351   {
64352     try {
64353       (arg1)->SetLabel(arg2);
64354     } catch (std::out_of_range& e) {
64355       {
64356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64357       };
64358     } catch (std::exception& e) {
64359       {
64360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64361       };
64362     } catch (...) {
64363       {
64364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64365       };
64366     }
64367   }
64368 }
64369
64370
64371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64372   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64373   Dali::Image arg2 ;
64374   Dali::Image *argp2 ;
64375
64376   arg1 = (Dali::Toolkit::Button *)jarg1;
64377   argp2 = (Dali::Image *)jarg2;
64378   if (!argp2) {
64379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64380     return ;
64381   }
64382   arg2 = *argp2;
64383   {
64384     try {
64385       (arg1)->SetButtonImage(arg2);
64386     } catch (std::out_of_range& e) {
64387       {
64388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64389       };
64390     } catch (std::exception& e) {
64391       {
64392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64393       };
64394     } catch (...) {
64395       {
64396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64397       };
64398     }
64399   }
64400 }
64401
64402
64403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64404   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64405   Dali::Image arg2 ;
64406   Dali::Image *argp2 ;
64407
64408   arg1 = (Dali::Toolkit::Button *)jarg1;
64409   argp2 = (Dali::Image *)jarg2;
64410   if (!argp2) {
64411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64412     return ;
64413   }
64414   arg2 = *argp2;
64415   {
64416     try {
64417       (arg1)->SetSelectedImage(arg2);
64418     } catch (std::out_of_range& e) {
64419       {
64420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64421       };
64422     } catch (std::exception& e) {
64423       {
64424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64425       };
64426     } catch (...) {
64427       {
64428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64429       };
64430     }
64431   }
64432 }
64433
64434
64435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64436   void * jresult ;
64437   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64438   Dali::Actor result;
64439
64440   arg1 = (Dali::Toolkit::Button *)jarg1;
64441   {
64442     try {
64443       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64444     } catch (std::out_of_range& e) {
64445       {
64446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64447       };
64448     } catch (std::exception& e) {
64449       {
64450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64451       };
64452     } catch (...) {
64453       {
64454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64455       };
64456     }
64457   }
64458   jresult = new Dali::Actor((const Dali::Actor &)result);
64459   return jresult;
64460 }
64461
64462
64463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64464   void * jresult ;
64465   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64466   Dali::Actor result;
64467
64468   arg1 = (Dali::Toolkit::Button *)jarg1;
64469   {
64470     try {
64471       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64472     } catch (std::out_of_range& e) {
64473       {
64474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64475       };
64476     } catch (std::exception& e) {
64477       {
64478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64479       };
64480     } catch (...) {
64481       {
64482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64483       };
64484     }
64485   }
64486   jresult = new Dali::Actor((const Dali::Actor &)result);
64487   return jresult;
64488 }
64489
64490
64491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64492   void * jresult ;
64493   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64494   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64495
64496   arg1 = (Dali::Toolkit::Button *)jarg1;
64497   {
64498     try {
64499       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64500     } catch (std::out_of_range& e) {
64501       {
64502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64503       };
64504     } catch (std::exception& e) {
64505       {
64506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (...) {
64509       {
64510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64511       };
64512     }
64513   }
64514   jresult = (void *)result;
64515   return jresult;
64516 }
64517
64518
64519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64520   void * jresult ;
64521   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64522   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64523
64524   arg1 = (Dali::Toolkit::Button *)jarg1;
64525   {
64526     try {
64527       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64528     } catch (std::out_of_range& e) {
64529       {
64530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64531       };
64532     } catch (std::exception& e) {
64533       {
64534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64535       };
64536     } catch (...) {
64537       {
64538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64539       };
64540     }
64541   }
64542   jresult = (void *)result;
64543   return jresult;
64544 }
64545
64546
64547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64548   void * jresult ;
64549   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64550   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64551
64552   arg1 = (Dali::Toolkit::Button *)jarg1;
64553   {
64554     try {
64555       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64556     } catch (std::out_of_range& e) {
64557       {
64558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64559       };
64560     } catch (std::exception& e) {
64561       {
64562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64563       };
64564     } catch (...) {
64565       {
64566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64567       };
64568     }
64569   }
64570   jresult = (void *)result;
64571   return jresult;
64572 }
64573
64574
64575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64576   void * jresult ;
64577   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64578   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64579
64580   arg1 = (Dali::Toolkit::Button *)jarg1;
64581   {
64582     try {
64583       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64584     } catch (std::out_of_range& e) {
64585       {
64586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64587       };
64588     } catch (std::exception& e) {
64589       {
64590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64591       };
64592     } catch (...) {
64593       {
64594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64595       };
64596     }
64597   }
64598   jresult = (void *)result;
64599   return jresult;
64600 }
64601
64602
64603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64604   void * jresult ;
64605   Dali::Toolkit::CheckBoxButton *result = 0 ;
64606
64607   {
64608     try {
64609       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64610     } catch (std::out_of_range& e) {
64611       {
64612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64613       };
64614     } catch (std::exception& e) {
64615       {
64616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64617       };
64618     } catch (...) {
64619       {
64620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64621       };
64622     }
64623   }
64624   jresult = (void *)result;
64625   return jresult;
64626 }
64627
64628
64629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64630   void * jresult ;
64631   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64632   Dali::Toolkit::CheckBoxButton *result = 0 ;
64633
64634   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64635   if (!arg1) {
64636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64637     return 0;
64638   }
64639   {
64640     try {
64641       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64642     } catch (std::out_of_range& e) {
64643       {
64644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64645       };
64646     } catch (std::exception& e) {
64647       {
64648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64649       };
64650     } catch (...) {
64651       {
64652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64653       };
64654     }
64655   }
64656   jresult = (void *)result;
64657   return jresult;
64658 }
64659
64660
64661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64662   void * jresult ;
64663   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64664   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64665   Dali::Toolkit::CheckBoxButton *result = 0 ;
64666
64667   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64668   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64669   if (!arg2) {
64670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64671     return 0;
64672   }
64673   {
64674     try {
64675       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64676     } catch (std::out_of_range& e) {
64677       {
64678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64679       };
64680     } catch (std::exception& e) {
64681       {
64682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64683       };
64684     } catch (...) {
64685       {
64686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64687       };
64688     }
64689   }
64690   jresult = (void *)result;
64691   return jresult;
64692 }
64693
64694
64695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64696   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64697
64698   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64699   {
64700     try {
64701       delete arg1;
64702     } catch (std::out_of_range& e) {
64703       {
64704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64705       };
64706     } catch (std::exception& e) {
64707       {
64708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64709       };
64710     } catch (...) {
64711       {
64712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64713       };
64714     }
64715   }
64716 }
64717
64718
64719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64720   void * jresult ;
64721   Dali::Toolkit::CheckBoxButton result;
64722
64723   {
64724     try {
64725       result = Dali::Toolkit::CheckBoxButton::New();
64726     } catch (std::out_of_range& e) {
64727       {
64728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64729       };
64730     } catch (std::exception& e) {
64731       {
64732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64733       };
64734     } catch (...) {
64735       {
64736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64737       };
64738     }
64739   }
64740   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64741   return jresult;
64742 }
64743
64744
64745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64746   void * jresult ;
64747   Dali::BaseHandle arg1 ;
64748   Dali::BaseHandle *argp1 ;
64749   Dali::Toolkit::CheckBoxButton result;
64750
64751   argp1 = (Dali::BaseHandle *)jarg1;
64752   if (!argp1) {
64753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64754     return 0;
64755   }
64756   arg1 = *argp1;
64757   {
64758     try {
64759       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64760     } catch (std::out_of_range& e) {
64761       {
64762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64763       };
64764     } catch (std::exception& e) {
64765       {
64766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64767       };
64768     } catch (...) {
64769       {
64770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64771       };
64772     }
64773   }
64774   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64775   return jresult;
64776 }
64777
64778
64779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64780   int jresult ;
64781   int result;
64782
64783   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64784   jresult = (int)result;
64785   return jresult;
64786 }
64787
64788
64789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64790   int jresult ;
64791   int result;
64792
64793   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64794   jresult = (int)result;
64795   return jresult;
64796 }
64797
64798
64799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64800   int jresult ;
64801   int result;
64802
64803   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64804   jresult = (int)result;
64805   return jresult;
64806 }
64807
64808
64809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64810   int jresult ;
64811   int result;
64812
64813   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64814   jresult = (int)result;
64815   return jresult;
64816 }
64817
64818
64819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64820   int jresult ;
64821   int result;
64822
64823   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64824   jresult = (int)result;
64825   return jresult;
64826 }
64827
64828
64829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64830   void * jresult ;
64831   Dali::Toolkit::PushButton::Property *result = 0 ;
64832
64833   {
64834     try {
64835       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64836     } catch (std::out_of_range& e) {
64837       {
64838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64839       };
64840     } catch (std::exception& e) {
64841       {
64842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64843       };
64844     } catch (...) {
64845       {
64846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64847       };
64848     }
64849   }
64850   jresult = (void *)result;
64851   return jresult;
64852 }
64853
64854
64855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64856   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64857
64858   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64859   {
64860     try {
64861       delete arg1;
64862     } catch (std::out_of_range& e) {
64863       {
64864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64865       };
64866     } catch (std::exception& e) {
64867       {
64868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64869       };
64870     } catch (...) {
64871       {
64872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64873       };
64874     }
64875   }
64876 }
64877
64878
64879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64880   void * jresult ;
64881   Dali::Toolkit::PushButton *result = 0 ;
64882
64883   {
64884     try {
64885       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64886     } catch (std::out_of_range& e) {
64887       {
64888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64889       };
64890     } catch (std::exception& e) {
64891       {
64892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64893       };
64894     } catch (...) {
64895       {
64896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64897       };
64898     }
64899   }
64900   jresult = (void *)result;
64901   return jresult;
64902 }
64903
64904
64905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64906   void * jresult ;
64907   Dali::Toolkit::PushButton *arg1 = 0 ;
64908   Dali::Toolkit::PushButton *result = 0 ;
64909
64910   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64911   if (!arg1) {
64912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64913     return 0;
64914   }
64915   {
64916     try {
64917       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64918     } catch (std::out_of_range& e) {
64919       {
64920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64921       };
64922     } catch (std::exception& e) {
64923       {
64924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64925       };
64926     } catch (...) {
64927       {
64928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64929       };
64930     }
64931   }
64932   jresult = (void *)result;
64933   return jresult;
64934 }
64935
64936
64937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64938   void * jresult ;
64939   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64940   Dali::Toolkit::PushButton *arg2 = 0 ;
64941   Dali::Toolkit::PushButton *result = 0 ;
64942
64943   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64944   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64945   if (!arg2) {
64946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64947     return 0;
64948   }
64949   {
64950     try {
64951       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
64952     } catch (std::out_of_range& e) {
64953       {
64954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64955       };
64956     } catch (std::exception& e) {
64957       {
64958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64959       };
64960     } catch (...) {
64961       {
64962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64963       };
64964     }
64965   }
64966   jresult = (void *)result;
64967   return jresult;
64968 }
64969
64970
64971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64972   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64973
64974   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64975   {
64976     try {
64977       delete arg1;
64978     } catch (std::out_of_range& e) {
64979       {
64980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64981       };
64982     } catch (std::exception& e) {
64983       {
64984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64985       };
64986     } catch (...) {
64987       {
64988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64989       };
64990     }
64991   }
64992 }
64993
64994
64995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
64996   void * jresult ;
64997   Dali::Toolkit::PushButton result;
64998
64999   {
65000     try {
65001       result = Dali::Toolkit::PushButton::New();
65002     } catch (std::out_of_range& e) {
65003       {
65004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (std::exception& e) {
65007       {
65008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65009       };
65010     } catch (...) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65013       };
65014     }
65015   }
65016   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65017   return jresult;
65018 }
65019
65020
65021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65022   void * jresult ;
65023   Dali::BaseHandle arg1 ;
65024   Dali::BaseHandle *argp1 ;
65025   Dali::Toolkit::PushButton result;
65026
65027   argp1 = (Dali::BaseHandle *)jarg1;
65028   if (!argp1) {
65029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65030     return 0;
65031   }
65032   arg1 = *argp1;
65033   {
65034     try {
65035       result = Dali::Toolkit::PushButton::DownCast(arg1);
65036     } catch (std::out_of_range& e) {
65037       {
65038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65039       };
65040     } catch (std::exception& e) {
65041       {
65042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65043       };
65044     } catch (...) {
65045       {
65046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65047       };
65048     }
65049   }
65050   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65051   return jresult;
65052 }
65053
65054
65055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65056   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65057   Dali::Image arg2 ;
65058   Dali::Image *argp2 ;
65059
65060   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65061   argp2 = (Dali::Image *)jarg2;
65062   if (!argp2) {
65063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65064     return ;
65065   }
65066   arg2 = *argp2;
65067   {
65068     try {
65069       (arg1)->SetButtonImage(arg2);
65070     } catch (std::out_of_range& e) {
65071       {
65072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65073       };
65074     } catch (std::exception& e) {
65075       {
65076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65077       };
65078     } catch (...) {
65079       {
65080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65081       };
65082     }
65083   }
65084 }
65085
65086
65087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65088   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65089   Dali::Actor arg2 ;
65090   Dali::Actor *argp2 ;
65091
65092   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65093   argp2 = (Dali::Actor *)jarg2;
65094   if (!argp2) {
65095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65096     return ;
65097   }
65098   arg2 = *argp2;
65099   {
65100     try {
65101       (arg1)->SetButtonImage(arg2);
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65109       };
65110     } catch (...) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65113       };
65114     }
65115   }
65116 }
65117
65118
65119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65120   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65121   Dali::Actor arg2 ;
65122   Dali::Actor *argp2 ;
65123
65124   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65125   argp2 = (Dali::Actor *)jarg2;
65126   if (!argp2) {
65127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65128     return ;
65129   }
65130   arg2 = *argp2;
65131   {
65132     try {
65133       (arg1)->SetBackgroundImage(arg2);
65134     } catch (std::out_of_range& e) {
65135       {
65136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65137       };
65138     } catch (std::exception& e) {
65139       {
65140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65141       };
65142     } catch (...) {
65143       {
65144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65145       };
65146     }
65147   }
65148 }
65149
65150
65151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65152   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65153   Dali::Image arg2 ;
65154   Dali::Image *argp2 ;
65155
65156   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65157   argp2 = (Dali::Image *)jarg2;
65158   if (!argp2) {
65159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65160     return ;
65161   }
65162   arg2 = *argp2;
65163   {
65164     try {
65165       (arg1)->SetSelectedImage(arg2);
65166     } catch (std::out_of_range& e) {
65167       {
65168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65169       };
65170     } catch (std::exception& e) {
65171       {
65172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65173       };
65174     } catch (...) {
65175       {
65176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65177       };
65178     }
65179   }
65180 }
65181
65182
65183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65184   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65185   Dali::Actor arg2 ;
65186   Dali::Actor *argp2 ;
65187
65188   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65189   argp2 = (Dali::Actor *)jarg2;
65190   if (!argp2) {
65191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65192     return ;
65193   }
65194   arg2 = *argp2;
65195   {
65196     try {
65197       (arg1)->SetSelectedImage(arg2);
65198     } catch (std::out_of_range& e) {
65199       {
65200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65201       };
65202     } catch (std::exception& e) {
65203       {
65204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65205       };
65206     } catch (...) {
65207       {
65208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65209       };
65210     }
65211   }
65212 }
65213
65214
65215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65216   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65217   Dali::Actor arg2 ;
65218   Dali::Actor *argp2 ;
65219
65220   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65221   argp2 = (Dali::Actor *)jarg2;
65222   if (!argp2) {
65223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65224     return ;
65225   }
65226   arg2 = *argp2;
65227   {
65228     try {
65229       (arg1)->SetSelectedBackgroundImage(arg2);
65230     } catch (std::out_of_range& e) {
65231       {
65232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65233       };
65234     } catch (std::exception& e) {
65235       {
65236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65237       };
65238     } catch (...) {
65239       {
65240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65241       };
65242     }
65243   }
65244 }
65245
65246
65247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65248   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65249   Dali::Actor arg2 ;
65250   Dali::Actor *argp2 ;
65251
65252   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65253   argp2 = (Dali::Actor *)jarg2;
65254   if (!argp2) {
65255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65256     return ;
65257   }
65258   arg2 = *argp2;
65259   {
65260     try {
65261       (arg1)->SetDisabledBackgroundImage(arg2);
65262     } catch (std::out_of_range& e) {
65263       {
65264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65265       };
65266     } catch (std::exception& e) {
65267       {
65268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65269       };
65270     } catch (...) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65273       };
65274     }
65275   }
65276 }
65277
65278
65279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65280   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65281   Dali::Actor arg2 ;
65282   Dali::Actor *argp2 ;
65283
65284   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65285   argp2 = (Dali::Actor *)jarg2;
65286   if (!argp2) {
65287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65288     return ;
65289   }
65290   arg2 = *argp2;
65291   {
65292     try {
65293       (arg1)->SetDisabledImage(arg2);
65294     } catch (std::out_of_range& e) {
65295       {
65296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65297       };
65298     } catch (std::exception& e) {
65299       {
65300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65301       };
65302     } catch (...) {
65303       {
65304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65305       };
65306     }
65307   }
65308 }
65309
65310
65311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65312   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65313   Dali::Actor arg2 ;
65314   Dali::Actor *argp2 ;
65315
65316   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65317   argp2 = (Dali::Actor *)jarg2;
65318   if (!argp2) {
65319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65320     return ;
65321   }
65322   arg2 = *argp2;
65323   {
65324     try {
65325       (arg1)->SetDisabledSelectedImage(arg2);
65326     } catch (std::out_of_range& e) {
65327       {
65328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65329       };
65330     } catch (std::exception& e) {
65331       {
65332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65333       };
65334     } catch (...) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65337       };
65338     }
65339   }
65340 }
65341
65342
65343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65344   void * jresult ;
65345   Dali::Toolkit::RadioButton *result = 0 ;
65346
65347   {
65348     try {
65349       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65350     } catch (std::out_of_range& e) {
65351       {
65352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (std::exception& e) {
65355       {
65356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65357       };
65358     } catch (...) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65361       };
65362     }
65363   }
65364   jresult = (void *)result;
65365   return jresult;
65366 }
65367
65368
65369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65370   void * jresult ;
65371   Dali::Toolkit::RadioButton *arg1 = 0 ;
65372   Dali::Toolkit::RadioButton *result = 0 ;
65373
65374   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65375   if (!arg1) {
65376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65377     return 0;
65378   }
65379   {
65380     try {
65381       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65382     } catch (std::out_of_range& e) {
65383       {
65384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65385       };
65386     } catch (std::exception& e) {
65387       {
65388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65389       };
65390     } catch (...) {
65391       {
65392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65393       };
65394     }
65395   }
65396   jresult = (void *)result;
65397   return jresult;
65398 }
65399
65400
65401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65402   void * jresult ;
65403   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65404   Dali::Toolkit::RadioButton *arg2 = 0 ;
65405   Dali::Toolkit::RadioButton *result = 0 ;
65406
65407   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65408   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65409   if (!arg2) {
65410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65411     return 0;
65412   }
65413   {
65414     try {
65415       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65416     } catch (std::out_of_range& e) {
65417       {
65418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65419       };
65420     } catch (std::exception& e) {
65421       {
65422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65423       };
65424     } catch (...) {
65425       {
65426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65427       };
65428     }
65429   }
65430   jresult = (void *)result;
65431   return jresult;
65432 }
65433
65434
65435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65436   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65437
65438   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65439   {
65440     try {
65441       delete arg1;
65442     } catch (std::out_of_range& e) {
65443       {
65444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65445       };
65446     } catch (std::exception& e) {
65447       {
65448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65449       };
65450     } catch (...) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65453       };
65454     }
65455   }
65456 }
65457
65458
65459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65460   void * jresult ;
65461   Dali::Toolkit::RadioButton result;
65462
65463   {
65464     try {
65465       result = Dali::Toolkit::RadioButton::New();
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65473       };
65474     } catch (...) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65477       };
65478     }
65479   }
65480   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65481   return jresult;
65482 }
65483
65484
65485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65486   void * jresult ;
65487   std::string *arg1 = 0 ;
65488   Dali::Toolkit::RadioButton result;
65489
65490   if (!jarg1) {
65491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65492     return 0;
65493   }
65494   std::string arg1_str(jarg1);
65495   arg1 = &arg1_str;
65496   {
65497     try {
65498       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65499     } catch (std::out_of_range& e) {
65500       {
65501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65502       };
65503     } catch (std::exception& e) {
65504       {
65505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65506       };
65507     } catch (...) {
65508       {
65509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65510       };
65511     }
65512   }
65513   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65514
65515   //argout typemap for const std::string&
65516
65517   return jresult;
65518 }
65519
65520
65521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65522   void * jresult ;
65523   Dali::BaseHandle arg1 ;
65524   Dali::BaseHandle *argp1 ;
65525   Dali::Toolkit::RadioButton result;
65526
65527   argp1 = (Dali::BaseHandle *)jarg1;
65528   if (!argp1) {
65529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65530     return 0;
65531   }
65532   arg1 = *argp1;
65533   {
65534     try {
65535       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65536     } catch (std::out_of_range& e) {
65537       {
65538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65539       };
65540     } catch (std::exception& e) {
65541       {
65542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65543       };
65544     } catch (...) {
65545       {
65546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65547       };
65548     }
65549   }
65550   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65551   return jresult;
65552 }
65553
65554
65555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65556   int jresult ;
65557   int result;
65558
65559   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65560   jresult = (int)result;
65561   return jresult;
65562 }
65563
65564
65565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65566   int jresult ;
65567   int result;
65568
65569   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65570   jresult = (int)result;
65571   return jresult;
65572 }
65573
65574
65575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65576   int jresult ;
65577   int result;
65578
65579   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65580   jresult = (int)result;
65581   return jresult;
65582 }
65583
65584
65585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65586   int jresult ;
65587   int result;
65588
65589   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65590   jresult = (int)result;
65591   return jresult;
65592 }
65593
65594
65595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65596   int jresult ;
65597   int result;
65598
65599   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65600   jresult = (int)result;
65601   return jresult;
65602 }
65603
65604
65605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65606   int jresult ;
65607   int result;
65608
65609   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65610   jresult = (int)result;
65611   return jresult;
65612 }
65613
65614
65615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65616   void * jresult ;
65617   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65618
65619   {
65620     try {
65621       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65622     } catch (std::out_of_range& e) {
65623       {
65624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65625       };
65626     } catch (std::exception& e) {
65627       {
65628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65629       };
65630     } catch (...) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65633       };
65634     }
65635   }
65636   jresult = (void *)result;
65637   return jresult;
65638 }
65639
65640
65641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65642   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65643
65644   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65645   {
65646     try {
65647       delete arg1;
65648     } catch (std::out_of_range& e) {
65649       {
65650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65651       };
65652     } catch (std::exception& e) {
65653       {
65654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65655       };
65656     } catch (...) {
65657       {
65658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65659       };
65660     }
65661   }
65662 }
65663
65664
65665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65666   int jresult ;
65667   int result;
65668
65669   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65670   jresult = (int)result;
65671   return jresult;
65672 }
65673
65674
65675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65676   int jresult ;
65677   int result;
65678
65679   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65680   jresult = (int)result;
65681   return jresult;
65682 }
65683
65684
65685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65686   int jresult ;
65687   int result;
65688
65689   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65690   jresult = (int)result;
65691   return jresult;
65692 }
65693
65694
65695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65696   void * jresult ;
65697   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65698
65699   {
65700     try {
65701       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (...) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65713       };
65714     }
65715   }
65716   jresult = (void *)result;
65717   return jresult;
65718 }
65719
65720
65721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65722   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65723
65724   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65725   {
65726     try {
65727       delete arg1;
65728     } catch (std::out_of_range& e) {
65729       {
65730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65731       };
65732     } catch (std::exception& e) {
65733       {
65734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65735       };
65736     } catch (...) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65739       };
65740     }
65741   }
65742 }
65743
65744
65745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65746   void * jresult ;
65747   Dali::Toolkit::FlexContainer *result = 0 ;
65748
65749   {
65750     try {
65751       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65752     } catch (std::out_of_range& e) {
65753       {
65754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65755       };
65756     } catch (std::exception& e) {
65757       {
65758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65759       };
65760     } catch (...) {
65761       {
65762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65763       };
65764     }
65765   }
65766   jresult = (void *)result;
65767   return jresult;
65768 }
65769
65770
65771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65772   void * jresult ;
65773   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65774   Dali::Toolkit::FlexContainer *result = 0 ;
65775
65776   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65777   if (!arg1) {
65778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65779     return 0;
65780   }
65781   {
65782     try {
65783       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65784     } catch (std::out_of_range& e) {
65785       {
65786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65787       };
65788     } catch (std::exception& e) {
65789       {
65790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65791       };
65792     } catch (...) {
65793       {
65794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65795       };
65796     }
65797   }
65798   jresult = (void *)result;
65799   return jresult;
65800 }
65801
65802
65803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65804   void * jresult ;
65805   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65806   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65807   Dali::Toolkit::FlexContainer *result = 0 ;
65808
65809   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65810   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65811   if (!arg2) {
65812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65813     return 0;
65814   }
65815   {
65816     try {
65817       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65818     } catch (std::out_of_range& e) {
65819       {
65820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65821       };
65822     } catch (std::exception& e) {
65823       {
65824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65825       };
65826     } catch (...) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65829       };
65830     }
65831   }
65832   jresult = (void *)result;
65833   return jresult;
65834 }
65835
65836
65837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65838   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65839
65840   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65841   {
65842     try {
65843       delete arg1;
65844     } catch (std::out_of_range& e) {
65845       {
65846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65847       };
65848     } catch (std::exception& e) {
65849       {
65850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65851       };
65852     } catch (...) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65855       };
65856     }
65857   }
65858 }
65859
65860
65861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65862   void * jresult ;
65863   Dali::Toolkit::FlexContainer result;
65864
65865   {
65866     try {
65867       result = Dali::Toolkit::FlexContainer::New();
65868     } catch (std::out_of_range& e) {
65869       {
65870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65871       };
65872     } catch (std::exception& e) {
65873       {
65874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65875       };
65876     } catch (...) {
65877       {
65878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65879       };
65880     }
65881   }
65882   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65883   return jresult;
65884 }
65885
65886
65887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65888   void * jresult ;
65889   Dali::BaseHandle arg1 ;
65890   Dali::BaseHandle *argp1 ;
65891   Dali::Toolkit::FlexContainer result;
65892
65893   argp1 = (Dali::BaseHandle *)jarg1;
65894   if (!argp1) {
65895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65896     return 0;
65897   }
65898   arg1 = *argp1;
65899   {
65900     try {
65901       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65902     } catch (std::out_of_range& e) {
65903       {
65904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65905       };
65906     } catch (std::exception& e) {
65907       {
65908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65909       };
65910     } catch (...) {
65911       {
65912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65913       };
65914     }
65915   }
65916   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65917   return jresult;
65918 }
65919
65920
65921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65922   int jresult ;
65923   int result;
65924
65925   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65926   jresult = (int)result;
65927   return jresult;
65928 }
65929
65930
65931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65932   int jresult ;
65933   int result;
65934
65935   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65936   jresult = (int)result;
65937   return jresult;
65938 }
65939
65940
65941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65942   int jresult ;
65943   int result;
65944
65945   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65946   jresult = (int)result;
65947   return jresult;
65948 }
65949
65950
65951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65952   int jresult ;
65953   int result;
65954
65955   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65956   jresult = (int)result;
65957   return jresult;
65958 }
65959
65960
65961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65962   void * jresult ;
65963   Dali::Toolkit::ImageView::Property *result = 0 ;
65964
65965   {
65966     try {
65967       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
65968     } catch (std::out_of_range& e) {
65969       {
65970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65971       };
65972     } catch (std::exception& e) {
65973       {
65974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65975       };
65976     } catch (...) {
65977       {
65978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65979       };
65980     }
65981   }
65982   jresult = (void *)result;
65983   return jresult;
65984 }
65985
65986
65987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65988   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65989
65990   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65991   {
65992     try {
65993       delete arg1;
65994     } catch (std::out_of_range& e) {
65995       {
65996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65997       };
65998     } catch (std::exception& e) {
65999       {
66000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66001       };
66002     } catch (...) {
66003       {
66004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66005       };
66006     }
66007   }
66008 }
66009
66010
66011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66012   void * jresult ;
66013   Dali::Toolkit::ImageView *result = 0 ;
66014
66015   {
66016     try {
66017       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66018     } catch (std::out_of_range& e) {
66019       {
66020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66021       };
66022     } catch (std::exception& e) {
66023       {
66024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66025       };
66026     } catch (...) {
66027       {
66028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66029       };
66030     }
66031   }
66032   jresult = (void *)result;
66033   return jresult;
66034 }
66035
66036
66037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66038   void * jresult ;
66039   Dali::Toolkit::ImageView result;
66040
66041   {
66042     try {
66043       result = Dali::Toolkit::ImageView::New();
66044     } catch (std::out_of_range& e) {
66045       {
66046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66047       };
66048     } catch (std::exception& e) {
66049       {
66050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66051       };
66052     } catch (...) {
66053       {
66054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66055       };
66056     }
66057   }
66058   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66059   return jresult;
66060 }
66061
66062
66063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66064   void * jresult ;
66065   Dali::Image arg1 ;
66066   Dali::Image *argp1 ;
66067   Dali::Toolkit::ImageView result;
66068
66069   argp1 = (Dali::Image *)jarg1;
66070   if (!argp1) {
66071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66072     return 0;
66073   }
66074   arg1 = *argp1;
66075   {
66076     try {
66077       result = Dali::Toolkit::ImageView::New(arg1);
66078     } catch (std::out_of_range& e) {
66079       {
66080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (std::exception& e) {
66083       {
66084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66089       };
66090     }
66091   }
66092   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66093   return jresult;
66094 }
66095
66096
66097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66098   void * jresult ;
66099   std::string *arg1 = 0 ;
66100   Dali::Toolkit::ImageView result;
66101
66102   if (!jarg1) {
66103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66104     return 0;
66105   }
66106   std::string arg1_str(jarg1);
66107   arg1 = &arg1_str;
66108   {
66109     try {
66110       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66111     } catch (std::out_of_range& e) {
66112       {
66113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66114       };
66115     } catch (std::exception& e) {
66116       {
66117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66118       };
66119     } catch (...) {
66120       {
66121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66122       };
66123     }
66124   }
66125   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66126
66127   //argout typemap for const std::string&
66128
66129   return jresult;
66130 }
66131
66132
66133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66134   void * jresult ;
66135   std::string *arg1 = 0 ;
66136   Dali::ImageDimensions arg2 ;
66137   Dali::ImageDimensions *argp2 ;
66138   Dali::Toolkit::ImageView result;
66139
66140   if (!jarg1) {
66141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66142     return 0;
66143   }
66144   std::string arg1_str(jarg1);
66145   arg1 = &arg1_str;
66146   argp2 = (Dali::ImageDimensions *)jarg2;
66147   if (!argp2) {
66148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66149     return 0;
66150   }
66151   arg2 = *argp2;
66152   {
66153     try {
66154       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66155     } catch (std::out_of_range& e) {
66156       {
66157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (std::exception& e) {
66160       {
66161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66166       };
66167     }
66168   }
66169   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66170
66171   //argout typemap for const std::string&
66172
66173   return jresult;
66174 }
66175
66176
66177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66178   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66179
66180   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66181   {
66182     try {
66183       delete arg1;
66184     } catch (std::out_of_range& e) {
66185       {
66186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66187       };
66188     } catch (std::exception& e) {
66189       {
66190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66191       };
66192     } catch (...) {
66193       {
66194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66195       };
66196     }
66197   }
66198 }
66199
66200
66201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66202   void * jresult ;
66203   Dali::Toolkit::ImageView *arg1 = 0 ;
66204   Dali::Toolkit::ImageView *result = 0 ;
66205
66206   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66207   if (!arg1) {
66208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66209     return 0;
66210   }
66211   {
66212     try {
66213       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66214     } catch (std::out_of_range& e) {
66215       {
66216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66217       };
66218     } catch (std::exception& e) {
66219       {
66220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66221       };
66222     } catch (...) {
66223       {
66224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66225       };
66226     }
66227   }
66228   jresult = (void *)result;
66229   return jresult;
66230 }
66231
66232
66233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66234   void * jresult ;
66235   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66236   Dali::Toolkit::ImageView *arg2 = 0 ;
66237   Dali::Toolkit::ImageView *result = 0 ;
66238
66239   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66240   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66241   if (!arg2) {
66242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66243     return 0;
66244   }
66245   {
66246     try {
66247       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66248     } catch (std::out_of_range& e) {
66249       {
66250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66251       };
66252     } catch (std::exception& e) {
66253       {
66254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66255       };
66256     } catch (...) {
66257       {
66258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66259       };
66260     }
66261   }
66262   jresult = (void *)result;
66263   return jresult;
66264 }
66265
66266
66267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66268   void * jresult ;
66269   Dali::BaseHandle arg1 ;
66270   Dali::BaseHandle *argp1 ;
66271   Dali::Toolkit::ImageView result;
66272
66273   argp1 = (Dali::BaseHandle *)jarg1;
66274   if (!argp1) {
66275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66276     return 0;
66277   }
66278   arg1 = *argp1;
66279   {
66280     try {
66281       result = Dali::Toolkit::ImageView::DownCast(arg1);
66282     } catch (std::out_of_range& e) {
66283       {
66284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66285       };
66286     } catch (std::exception& e) {
66287       {
66288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66289       };
66290     } catch (...) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66293       };
66294     }
66295   }
66296   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66297   return jresult;
66298 }
66299
66300
66301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66302   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66303   Dali::Image arg2 ;
66304   Dali::Image *argp2 ;
66305
66306   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66307   argp2 = (Dali::Image *)jarg2;
66308   if (!argp2) {
66309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66310     return ;
66311   }
66312   arg2 = *argp2;
66313   {
66314     try {
66315       (arg1)->SetImage(arg2);
66316     } catch (std::out_of_range& e) {
66317       {
66318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66319       };
66320     } catch (std::exception& e) {
66321       {
66322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66323       };
66324     } catch (...) {
66325       {
66326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66327       };
66328     }
66329   }
66330 }
66331
66332
66333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66334   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66335   std::string *arg2 = 0 ;
66336
66337   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66338   if (!jarg2) {
66339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66340     return ;
66341   }
66342   std::string arg2_str(jarg2);
66343   arg2 = &arg2_str;
66344   {
66345     try {
66346       (arg1)->SetImage((std::string const &)*arg2);
66347     } catch (std::out_of_range& e) {
66348       {
66349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66350       };
66351     } catch (std::exception& e) {
66352       {
66353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66354       };
66355     } catch (...) {
66356       {
66357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66358       };
66359     }
66360   }
66361
66362   //argout typemap for const std::string&
66363
66364 }
66365
66366
66367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66368   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66369   std::string *arg2 = 0 ;
66370   Dali::ImageDimensions arg3 ;
66371   Dali::ImageDimensions *argp3 ;
66372
66373   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66374   if (!jarg2) {
66375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66376     return ;
66377   }
66378   std::string arg2_str(jarg2);
66379   arg2 = &arg2_str;
66380   argp3 = (Dali::ImageDimensions *)jarg3;
66381   if (!argp3) {
66382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66383     return ;
66384   }
66385   arg3 = *argp3;
66386   {
66387     try {
66388       (arg1)->SetImage((std::string const &)*arg2,arg3);
66389     } catch (std::out_of_range& e) {
66390       {
66391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66392       };
66393     } catch (std::exception& e) {
66394       {
66395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (...) {
66398       {
66399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66400       };
66401     }
66402   }
66403
66404   //argout typemap for const std::string&
66405
66406 }
66407
66408
66409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66410   void * jresult ;
66411   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66412   Dali::Image result;
66413
66414   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66415   {
66416     try {
66417       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (...) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66429       };
66430     }
66431   }
66432   jresult = new Dali::Image((const Dali::Image &)result);
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66438   int jresult ;
66439   int result;
66440
66441   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66442   jresult = (int)result;
66443   return jresult;
66444 }
66445
66446
66447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66448   int jresult ;
66449   int result;
66450
66451   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66452   jresult = (int)result;
66453   return jresult;
66454 }
66455
66456
66457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66458   int jresult ;
66459   int result;
66460
66461   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66462   jresult = (int)result;
66463   return jresult;
66464 }
66465
66466
66467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66468   int jresult ;
66469   int result;
66470
66471   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66472   jresult = (int)result;
66473   return jresult;
66474 }
66475
66476
66477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66478   int jresult ;
66479   int result;
66480
66481   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66482   jresult = (int)result;
66483   return jresult;
66484 }
66485
66486
66487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66488   int jresult ;
66489   int result;
66490
66491   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66492   jresult = (int)result;
66493   return jresult;
66494 }
66495
66496
66497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66498   int jresult ;
66499   int result;
66500
66501   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66502   jresult = (int)result;
66503   return jresult;
66504 }
66505
66506
66507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66508   int jresult ;
66509   int result;
66510
66511   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66512   jresult = (int)result;
66513   return jresult;
66514 }
66515
66516
66517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66518   void * jresult ;
66519   Dali::Toolkit::Model3dView::Property *result = 0 ;
66520
66521   {
66522     try {
66523       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66524     } catch (std::out_of_range& e) {
66525       {
66526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66527       };
66528     } catch (std::exception& e) {
66529       {
66530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66535       };
66536     }
66537   }
66538   jresult = (void *)result;
66539   return jresult;
66540 }
66541
66542
66543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66544   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66545
66546   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66547   {
66548     try {
66549       delete arg1;
66550     } catch (std::out_of_range& e) {
66551       {
66552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66553       };
66554     } catch (std::exception& e) {
66555       {
66556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66557       };
66558     } catch (...) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66561       };
66562     }
66563   }
66564 }
66565
66566
66567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66568   void * jresult ;
66569   Dali::Toolkit::Model3dView result;
66570
66571   {
66572     try {
66573       result = Dali::Toolkit::Model3dView::New();
66574     } catch (std::out_of_range& e) {
66575       {
66576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66577       };
66578     } catch (std::exception& e) {
66579       {
66580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66581       };
66582     } catch (...) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66585       };
66586     }
66587   }
66588   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66589   return jresult;
66590 }
66591
66592
66593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66594   void * jresult ;
66595   std::string *arg1 = 0 ;
66596   std::string *arg2 = 0 ;
66597   std::string *arg3 = 0 ;
66598   Dali::Toolkit::Model3dView result;
66599
66600   if (!jarg1) {
66601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66602     return 0;
66603   }
66604   std::string arg1_str(jarg1);
66605   arg1 = &arg1_str;
66606   if (!jarg2) {
66607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66608     return 0;
66609   }
66610   std::string arg2_str(jarg2);
66611   arg2 = &arg2_str;
66612   if (!jarg3) {
66613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66614     return 0;
66615   }
66616   std::string arg3_str(jarg3);
66617   arg3 = &arg3_str;
66618   {
66619     try {
66620       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66621     } catch (std::out_of_range& e) {
66622       {
66623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66624       };
66625     } catch (std::exception& e) {
66626       {
66627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66628       };
66629     } catch (...) {
66630       {
66631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66632       };
66633     }
66634   }
66635   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66636
66637   //argout typemap for const std::string&
66638
66639
66640   //argout typemap for const std::string&
66641
66642
66643   //argout typemap for const std::string&
66644
66645   return jresult;
66646 }
66647
66648
66649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66650   void * jresult ;
66651   Dali::Toolkit::Model3dView *result = 0 ;
66652
66653   {
66654     try {
66655       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66656     } catch (std::out_of_range& e) {
66657       {
66658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66659       };
66660     } catch (std::exception& e) {
66661       {
66662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66663       };
66664     } catch (...) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66667       };
66668     }
66669   }
66670   jresult = (void *)result;
66671   return jresult;
66672 }
66673
66674
66675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66676   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66677
66678   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66679   {
66680     try {
66681       delete arg1;
66682     } catch (std::out_of_range& e) {
66683       {
66684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66685       };
66686     } catch (std::exception& e) {
66687       {
66688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66689       };
66690     } catch (...) {
66691       {
66692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66693       };
66694     }
66695   }
66696 }
66697
66698
66699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66700   void * jresult ;
66701   Dali::Toolkit::Model3dView *arg1 = 0 ;
66702   Dali::Toolkit::Model3dView *result = 0 ;
66703
66704   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66705   if (!arg1) {
66706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66707     return 0;
66708   }
66709   {
66710     try {
66711       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66712     } catch (std::out_of_range& e) {
66713       {
66714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66715       };
66716     } catch (std::exception& e) {
66717       {
66718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66719       };
66720     } catch (...) {
66721       {
66722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66723       };
66724     }
66725   }
66726   jresult = (void *)result;
66727   return jresult;
66728 }
66729
66730
66731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66732   void * jresult ;
66733   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66734   Dali::Toolkit::Model3dView *arg2 = 0 ;
66735   Dali::Toolkit::Model3dView *result = 0 ;
66736
66737   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66738   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66739   if (!arg2) {
66740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66741     return 0;
66742   }
66743   {
66744     try {
66745       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66746     } catch (std::out_of_range& e) {
66747       {
66748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66749       };
66750     } catch (std::exception& e) {
66751       {
66752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66753       };
66754     } catch (...) {
66755       {
66756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66757       };
66758     }
66759   }
66760   jresult = (void *)result;
66761   return jresult;
66762 }
66763
66764
66765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66766   void * jresult ;
66767   Dali::BaseHandle arg1 ;
66768   Dali::BaseHandle *argp1 ;
66769   Dali::Toolkit::Model3dView result;
66770
66771   argp1 = (Dali::BaseHandle *)jarg1;
66772   if (!argp1) {
66773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66774     return 0;
66775   }
66776   arg1 = *argp1;
66777   {
66778     try {
66779       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66780     } catch (std::out_of_range& e) {
66781       {
66782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66783       };
66784     } catch (std::exception& e) {
66785       {
66786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66787       };
66788     } catch (...) {
66789       {
66790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66791       };
66792     }
66793   }
66794   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66795   return jresult;
66796 }
66797
66798
66799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66800   int jresult ;
66801   int result;
66802
66803   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66804   jresult = (int)result;
66805   return jresult;
66806 }
66807
66808
66809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66810   int jresult ;
66811   int result;
66812
66813   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66814   jresult = (int)result;
66815   return jresult;
66816 }
66817
66818
66819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66820   int jresult ;
66821   int result;
66822
66823   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66824   jresult = (int)result;
66825   return jresult;
66826 }
66827
66828
66829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66830   int jresult ;
66831   int result;
66832
66833   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66834   jresult = (int)result;
66835   return jresult;
66836 }
66837
66838
66839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66840   int jresult ;
66841   int result;
66842
66843   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66844   jresult = (int)result;
66845   return jresult;
66846 }
66847
66848
66849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66850   int jresult ;
66851   int result;
66852
66853   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66854   jresult = (int)result;
66855   return jresult;
66856 }
66857
66858
66859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66860   int jresult ;
66861   int result;
66862
66863   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66864   jresult = (int)result;
66865   return jresult;
66866 }
66867
66868
66869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66870   int jresult ;
66871   int result;
66872
66873   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66874   jresult = (int)result;
66875   return jresult;
66876 }
66877
66878
66879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66880   int jresult ;
66881   int result;
66882
66883   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66884   jresult = (int)result;
66885   return jresult;
66886 }
66887
66888
66889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66890   void * jresult ;
66891   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66892
66893   {
66894     try {
66895       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66896     } catch (std::out_of_range& e) {
66897       {
66898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66899       };
66900     } catch (std::exception& e) {
66901       {
66902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66903       };
66904     } catch (...) {
66905       {
66906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66907       };
66908     }
66909   }
66910   jresult = (void *)result;
66911   return jresult;
66912 }
66913
66914
66915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66916   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66917
66918   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66919   {
66920     try {
66921       delete arg1;
66922     } catch (std::out_of_range& e) {
66923       {
66924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66925       };
66926     } catch (std::exception& e) {
66927       {
66928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66929       };
66930     } catch (...) {
66931       {
66932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66933       };
66934     }
66935   }
66936 }
66937
66938
66939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66940   void * jresult ;
66941   Dali::Toolkit::ScrollBar *result = 0 ;
66942
66943   {
66944     try {
66945       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66946     } catch (std::out_of_range& e) {
66947       {
66948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66949       };
66950     } catch (std::exception& e) {
66951       {
66952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66953       };
66954     } catch (...) {
66955       {
66956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66957       };
66958     }
66959   }
66960   jresult = (void *)result;
66961   return jresult;
66962 }
66963
66964
66965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66966   void * jresult ;
66967   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66968   Dali::Toolkit::ScrollBar *result = 0 ;
66969
66970   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66971   if (!arg1) {
66972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66973     return 0;
66974   }
66975   {
66976     try {
66977       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66978     } catch (std::out_of_range& e) {
66979       {
66980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66981       };
66982     } catch (std::exception& e) {
66983       {
66984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66985       };
66986     } catch (...) {
66987       {
66988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66989       };
66990     }
66991   }
66992   jresult = (void *)result;
66993   return jresult;
66994 }
66995
66996
66997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
66998   void * jresult ;
66999   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67000   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67001   Dali::Toolkit::ScrollBar *result = 0 ;
67002
67003   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67004   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67005   if (!arg2) {
67006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67007     return 0;
67008   }
67009   {
67010     try {
67011       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67012     } catch (std::out_of_range& e) {
67013       {
67014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67015       };
67016     } catch (std::exception& e) {
67017       {
67018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67019       };
67020     } catch (...) {
67021       {
67022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67023       };
67024     }
67025   }
67026   jresult = (void *)result;
67027   return jresult;
67028 }
67029
67030
67031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67032   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67033
67034   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67035   {
67036     try {
67037       delete arg1;
67038     } catch (std::out_of_range& e) {
67039       {
67040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67041       };
67042     } catch (std::exception& e) {
67043       {
67044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67045       };
67046     } catch (...) {
67047       {
67048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67049       };
67050     }
67051   }
67052 }
67053
67054
67055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67056   void * jresult ;
67057   Dali::Toolkit::ScrollBar::Direction arg1 ;
67058   Dali::Toolkit::ScrollBar result;
67059
67060   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67061   {
67062     try {
67063       result = Dali::Toolkit::ScrollBar::New(arg1);
67064     } catch (std::out_of_range& e) {
67065       {
67066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67067       };
67068     } catch (std::exception& e) {
67069       {
67070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67071       };
67072     } catch (...) {
67073       {
67074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67075       };
67076     }
67077   }
67078   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67079   return jresult;
67080 }
67081
67082
67083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67084   void * jresult ;
67085   Dali::Toolkit::ScrollBar result;
67086
67087   {
67088     try {
67089       result = Dali::Toolkit::ScrollBar::New();
67090     } catch (std::out_of_range& e) {
67091       {
67092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67093       };
67094     } catch (std::exception& e) {
67095       {
67096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67101       };
67102     }
67103   }
67104   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67105   return jresult;
67106 }
67107
67108
67109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67110   void * jresult ;
67111   Dali::BaseHandle arg1 ;
67112   Dali::BaseHandle *argp1 ;
67113   Dali::Toolkit::ScrollBar result;
67114
67115   argp1 = (Dali::BaseHandle *)jarg1;
67116   if (!argp1) {
67117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67118     return 0;
67119   }
67120   arg1 = *argp1;
67121   {
67122     try {
67123       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67124     } catch (std::out_of_range& e) {
67125       {
67126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67127       };
67128     } catch (std::exception& e) {
67129       {
67130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67131       };
67132     } catch (...) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67135       };
67136     }
67137   }
67138   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67139   return jresult;
67140 }
67141
67142
67143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67144   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67145   Dali::Handle arg2 ;
67146   Dali::Property::Index arg3 ;
67147   Dali::Property::Index arg4 ;
67148   Dali::Property::Index arg5 ;
67149   Dali::Property::Index arg6 ;
67150   Dali::Handle *argp2 ;
67151
67152   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67153   argp2 = (Dali::Handle *)jarg2;
67154   if (!argp2) {
67155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67156     return ;
67157   }
67158   arg2 = *argp2;
67159   arg3 = (Dali::Property::Index)jarg3;
67160   arg4 = (Dali::Property::Index)jarg4;
67161   arg5 = (Dali::Property::Index)jarg5;
67162   arg6 = (Dali::Property::Index)jarg6;
67163   {
67164     try {
67165       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67166     } catch (std::out_of_range& e) {
67167       {
67168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67169       };
67170     } catch (std::exception& e) {
67171       {
67172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67173       };
67174     } catch (...) {
67175       {
67176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67177       };
67178     }
67179   }
67180 }
67181
67182
67183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67184   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67185   Dali::Actor arg2 ;
67186   Dali::Actor *argp2 ;
67187
67188   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67189   argp2 = (Dali::Actor *)jarg2;
67190   if (!argp2) {
67191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67192     return ;
67193   }
67194   arg2 = *argp2;
67195   {
67196     try {
67197       (arg1)->SetScrollIndicator(arg2);
67198     } catch (std::out_of_range& e) {
67199       {
67200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67201       };
67202     } catch (std::exception& e) {
67203       {
67204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67205       };
67206     } catch (...) {
67207       {
67208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67209       };
67210     }
67211   }
67212 }
67213
67214
67215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67216   void * jresult ;
67217   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67218   Dali::Actor result;
67219
67220   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67221   {
67222     try {
67223       result = (arg1)->GetScrollIndicator();
67224     } catch (std::out_of_range& e) {
67225       {
67226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67227       };
67228     } catch (std::exception& e) {
67229       {
67230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67231       };
67232     } catch (...) {
67233       {
67234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67235       };
67236     }
67237   }
67238   jresult = new Dali::Actor((const Dali::Actor &)result);
67239   return jresult;
67240 }
67241
67242
67243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67244   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67245   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67246
67247   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67248   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67249   if (!arg2) {
67250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67251     return ;
67252   }
67253   {
67254     try {
67255       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67256     } catch (std::out_of_range& e) {
67257       {
67258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67259       };
67260     } catch (std::exception& e) {
67261       {
67262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67267       };
67268     }
67269   }
67270 }
67271
67272
67273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67274   void * jresult ;
67275   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67276   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67277
67278   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67279   {
67280     try {
67281       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67282     } catch (std::out_of_range& e) {
67283       {
67284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67285       };
67286     } catch (std::exception& e) {
67287       {
67288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67289       };
67290     } catch (...) {
67291       {
67292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67293       };
67294     }
67295   }
67296   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67297   return jresult;
67298 }
67299
67300
67301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67302   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67303   Dali::Toolkit::ScrollBar::Direction arg2 ;
67304
67305   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67306   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67307   {
67308     try {
67309       (arg1)->SetScrollDirection(arg2);
67310     } catch (std::out_of_range& e) {
67311       {
67312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67313       };
67314     } catch (std::exception& e) {
67315       {
67316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67317       };
67318     } catch (...) {
67319       {
67320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67321       };
67322     }
67323   }
67324 }
67325
67326
67327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67328   int jresult ;
67329   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67330   Dali::Toolkit::ScrollBar::Direction result;
67331
67332   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67333   {
67334     try {
67335       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67336     } catch (std::out_of_range& e) {
67337       {
67338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (std::exception& e) {
67341       {
67342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (...) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67347       };
67348     }
67349   }
67350   jresult = (int)result;
67351   return jresult;
67352 }
67353
67354
67355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67356   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67357   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67358
67359   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67360   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67361   {
67362     try {
67363       (arg1)->SetIndicatorHeightPolicy(arg2);
67364     } catch (std::out_of_range& e) {
67365       {
67366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67367       };
67368     } catch (std::exception& e) {
67369       {
67370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67371       };
67372     } catch (...) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67375       };
67376     }
67377   }
67378 }
67379
67380
67381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67382   int jresult ;
67383   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67384   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67385
67386   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67387   {
67388     try {
67389       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67390     } catch (std::out_of_range& e) {
67391       {
67392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67393       };
67394     } catch (std::exception& e) {
67395       {
67396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67397       };
67398     } catch (...) {
67399       {
67400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67401       };
67402     }
67403   }
67404   jresult = (int)result;
67405   return jresult;
67406 }
67407
67408
67409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67410   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67411   float arg2 ;
67412
67413   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67414   arg2 = (float)jarg2;
67415   {
67416     try {
67417       (arg1)->SetIndicatorFixedHeight(arg2);
67418     } catch (std::out_of_range& e) {
67419       {
67420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67421       };
67422     } catch (std::exception& e) {
67423       {
67424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67425       };
67426     } catch (...) {
67427       {
67428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67429       };
67430     }
67431   }
67432 }
67433
67434
67435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67436   float jresult ;
67437   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67438   float result;
67439
67440   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67441   {
67442     try {
67443       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67444     } catch (std::out_of_range& e) {
67445       {
67446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67447       };
67448     } catch (std::exception& e) {
67449       {
67450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67451       };
67452     } catch (...) {
67453       {
67454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67455       };
67456     }
67457   }
67458   jresult = result;
67459   return jresult;
67460 }
67461
67462
67463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67464   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67465   float arg2 ;
67466
67467   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67468   arg2 = (float)jarg2;
67469   {
67470     try {
67471       (arg1)->SetIndicatorShowDuration(arg2);
67472     } catch (std::out_of_range& e) {
67473       {
67474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67475       };
67476     } catch (std::exception& e) {
67477       {
67478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67479       };
67480     } catch (...) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67483       };
67484     }
67485   }
67486 }
67487
67488
67489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67490   float jresult ;
67491   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67492   float result;
67493
67494   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67495   {
67496     try {
67497       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67498     } catch (std::out_of_range& e) {
67499       {
67500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (std::exception& e) {
67503       {
67504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67505       };
67506     } catch (...) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67509       };
67510     }
67511   }
67512   jresult = result;
67513   return jresult;
67514 }
67515
67516
67517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67518   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67519   float arg2 ;
67520
67521   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67522   arg2 = (float)jarg2;
67523   {
67524     try {
67525       (arg1)->SetIndicatorHideDuration(arg2);
67526     } catch (std::out_of_range& e) {
67527       {
67528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67529       };
67530     } catch (std::exception& e) {
67531       {
67532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67533       };
67534     } catch (...) {
67535       {
67536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67537       };
67538     }
67539   }
67540 }
67541
67542
67543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67544   float jresult ;
67545   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67546   float result;
67547
67548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67549   {
67550     try {
67551       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67552     } catch (std::out_of_range& e) {
67553       {
67554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67555       };
67556     } catch (std::exception& e) {
67557       {
67558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67559       };
67560     } catch (...) {
67561       {
67562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67563       };
67564     }
67565   }
67566   jresult = result;
67567   return jresult;
67568 }
67569
67570
67571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67572   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67573
67574   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67575   {
67576     try {
67577       (arg1)->ShowIndicator();
67578     } catch (std::out_of_range& e) {
67579       {
67580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67581       };
67582     } catch (std::exception& e) {
67583       {
67584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67585       };
67586     } catch (...) {
67587       {
67588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67589       };
67590     }
67591   }
67592 }
67593
67594
67595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67596   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67597
67598   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67599   {
67600     try {
67601       (arg1)->HideIndicator();
67602     } catch (std::out_of_range& e) {
67603       {
67604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67605       };
67606     } catch (std::exception& e) {
67607       {
67608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67609       };
67610     } catch (...) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67613       };
67614     }
67615   }
67616 }
67617
67618
67619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67620   void * jresult ;
67621   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67622   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67623
67624   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67625   {
67626     try {
67627       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67628     } catch (std::out_of_range& e) {
67629       {
67630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67631       };
67632     } catch (std::exception& e) {
67633       {
67634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67635       };
67636     } catch (...) {
67637       {
67638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67639       };
67640     }
67641   }
67642   jresult = (void *)result;
67643   return jresult;
67644 }
67645
67646
67647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67648   void * jresult ;
67649   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67650   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67651
67652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67653   {
67654     try {
67655       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (...) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67667       };
67668     }
67669   }
67670   jresult = (void *)result;
67671   return jresult;
67672 }
67673
67674
67675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67676   int jresult ;
67677   int result;
67678
67679   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67680   jresult = (int)result;
67681   return jresult;
67682 }
67683
67684
67685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67686   int jresult ;
67687   int result;
67688
67689   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67690   jresult = (int)result;
67691   return jresult;
67692 }
67693
67694
67695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67696   int jresult ;
67697   int result;
67698
67699   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67700   jresult = (int)result;
67701   return jresult;
67702 }
67703
67704
67705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67706   int jresult ;
67707   int result;
67708
67709   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67710   jresult = (int)result;
67711   return jresult;
67712 }
67713
67714
67715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67716   int jresult ;
67717   int result;
67718
67719   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67720   jresult = (int)result;
67721   return jresult;
67722 }
67723
67724
67725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67726   int jresult ;
67727   int result;
67728
67729   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67730   jresult = (int)result;
67731   return jresult;
67732 }
67733
67734
67735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67736   int jresult ;
67737   int result;
67738
67739   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67740   jresult = (int)result;
67741   return jresult;
67742 }
67743
67744
67745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67746   int jresult ;
67747   int result;
67748
67749   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67750   jresult = (int)result;
67751   return jresult;
67752 }
67753
67754
67755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67756   int jresult ;
67757   int result;
67758
67759   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67760   jresult = (int)result;
67761   return jresult;
67762 }
67763
67764
67765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67766   int jresult ;
67767   int result;
67768
67769   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67770   jresult = (int)result;
67771   return jresult;
67772 }
67773
67774
67775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67776   int jresult ;
67777   int result;
67778
67779   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67780   jresult = (int)result;
67781   return jresult;
67782 }
67783
67784
67785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67786   int jresult ;
67787   int result;
67788
67789   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67790   jresult = (int)result;
67791   return jresult;
67792 }
67793
67794
67795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67796   int jresult ;
67797   int result;
67798
67799   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67800   jresult = (int)result;
67801   return jresult;
67802 }
67803
67804
67805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67806   int jresult ;
67807   int result;
67808
67809   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67810   jresult = (int)result;
67811   return jresult;
67812 }
67813
67814
67815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67816   void * jresult ;
67817   Dali::Toolkit::Scrollable::Property *result = 0 ;
67818
67819   {
67820     try {
67821       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67822     } catch (std::out_of_range& e) {
67823       {
67824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (std::exception& e) {
67827       {
67828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67829       };
67830     } catch (...) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67833       };
67834     }
67835   }
67836   jresult = (void *)result;
67837   return jresult;
67838 }
67839
67840
67841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67842   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67843
67844   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67845   {
67846     try {
67847       delete arg1;
67848     } catch (std::out_of_range& e) {
67849       {
67850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67851       };
67852     } catch (std::exception& e) {
67853       {
67854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67855       };
67856     } catch (...) {
67857       {
67858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67859       };
67860     }
67861   }
67862 }
67863
67864
67865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67866   void * jresult ;
67867   Dali::Toolkit::Scrollable *result = 0 ;
67868
67869   {
67870     try {
67871       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67872     } catch (std::out_of_range& e) {
67873       {
67874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67875       };
67876     } catch (std::exception& e) {
67877       {
67878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67879       };
67880     } catch (...) {
67881       {
67882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67883       };
67884     }
67885   }
67886   jresult = (void *)result;
67887   return jresult;
67888 }
67889
67890
67891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67892   void * jresult ;
67893   Dali::Toolkit::Scrollable *arg1 = 0 ;
67894   Dali::Toolkit::Scrollable *result = 0 ;
67895
67896   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67897   if (!arg1) {
67898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67899     return 0;
67900   }
67901   {
67902     try {
67903       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67904     } catch (std::out_of_range& e) {
67905       {
67906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67907       };
67908     } catch (std::exception& e) {
67909       {
67910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67911       };
67912     } catch (...) {
67913       {
67914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67915       };
67916     }
67917   }
67918   jresult = (void *)result;
67919   return jresult;
67920 }
67921
67922
67923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67924   void * jresult ;
67925   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67926   Dali::Toolkit::Scrollable *arg2 = 0 ;
67927   Dali::Toolkit::Scrollable *result = 0 ;
67928
67929   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67930   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67931   if (!arg2) {
67932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67933     return 0;
67934   }
67935   {
67936     try {
67937       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67938     } catch (std::out_of_range& e) {
67939       {
67940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67941       };
67942     } catch (std::exception& e) {
67943       {
67944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67945       };
67946     } catch (...) {
67947       {
67948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67949       };
67950     }
67951   }
67952   jresult = (void *)result;
67953   return jresult;
67954 }
67955
67956
67957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67958   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67959
67960   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67961   {
67962     try {
67963       delete arg1;
67964     } catch (std::out_of_range& e) {
67965       {
67966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67967       };
67968     } catch (std::exception& e) {
67969       {
67970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67971       };
67972     } catch (...) {
67973       {
67974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67975       };
67976     }
67977   }
67978 }
67979
67980
67981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67982   void * jresult ;
67983   Dali::BaseHandle arg1 ;
67984   Dali::BaseHandle *argp1 ;
67985   Dali::Toolkit::Scrollable result;
67986
67987   argp1 = (Dali::BaseHandle *)jarg1;
67988   if (!argp1) {
67989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67990     return 0;
67991   }
67992   arg1 = *argp1;
67993   {
67994     try {
67995       result = Dali::Toolkit::Scrollable::DownCast(arg1);
67996     } catch (std::out_of_range& e) {
67997       {
67998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67999       };
68000     } catch (std::exception& e) {
68001       {
68002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68003       };
68004     } catch (...) {
68005       {
68006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68007       };
68008     }
68009   }
68010   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68011   return jresult;
68012 }
68013
68014
68015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68016   unsigned int jresult ;
68017   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68018   bool result;
68019
68020   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68021   {
68022     try {
68023       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68024     } catch (std::out_of_range& e) {
68025       {
68026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (std::exception& e) {
68029       {
68030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68031       };
68032     } catch (...) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68035       };
68036     }
68037   }
68038   jresult = result;
68039   return jresult;
68040 }
68041
68042
68043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68044   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68045   bool arg2 ;
68046
68047   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68048   arg2 = jarg2 ? true : false;
68049   {
68050     try {
68051       (arg1)->SetOvershootEnabled(arg2);
68052     } catch (std::out_of_range& e) {
68053       {
68054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68055       };
68056     } catch (std::exception& e) {
68057       {
68058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68059       };
68060     } catch (...) {
68061       {
68062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68063       };
68064     }
68065   }
68066 }
68067
68068
68069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68070   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68071   Dali::Vector4 *arg2 = 0 ;
68072
68073   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68074   arg2 = (Dali::Vector4 *)jarg2;
68075   if (!arg2) {
68076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68077     return ;
68078   }
68079   {
68080     try {
68081       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68082     } catch (std::out_of_range& e) {
68083       {
68084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68085       };
68086     } catch (std::exception& e) {
68087       {
68088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68089       };
68090     } catch (...) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68093       };
68094     }
68095   }
68096 }
68097
68098
68099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68100   void * jresult ;
68101   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68102   Dali::Vector4 result;
68103
68104   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68105   {
68106     try {
68107       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68108     } catch (std::out_of_range& e) {
68109       {
68110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68111       };
68112     } catch (std::exception& e) {
68113       {
68114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68115       };
68116     } catch (...) {
68117       {
68118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68119       };
68120     }
68121   }
68122   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68123   return jresult;
68124 }
68125
68126
68127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68128   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68129   float arg2 ;
68130
68131   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68132   arg2 = (float)jarg2;
68133   {
68134     try {
68135       (arg1)->SetOvershootAnimationSpeed(arg2);
68136     } catch (std::out_of_range& e) {
68137       {
68138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68139       };
68140     } catch (std::exception& e) {
68141       {
68142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68143       };
68144     } catch (...) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68147       };
68148     }
68149   }
68150 }
68151
68152
68153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68154   float jresult ;
68155   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68156   float result;
68157
68158   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68159   {
68160     try {
68161       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68162     } catch (std::out_of_range& e) {
68163       {
68164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68165       };
68166     } catch (std::exception& e) {
68167       {
68168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68169       };
68170     } catch (...) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68173       };
68174     }
68175   }
68176   jresult = result;
68177   return jresult;
68178 }
68179
68180
68181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68182   void * jresult ;
68183   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68184   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68185
68186   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68187   {
68188     try {
68189       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68190     } catch (std::out_of_range& e) {
68191       {
68192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68193       };
68194     } catch (std::exception& e) {
68195       {
68196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68197       };
68198     } catch (...) {
68199       {
68200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68201       };
68202     }
68203   }
68204   jresult = (void *)result;
68205   return jresult;
68206 }
68207
68208
68209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68210   void * jresult ;
68211   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68212   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68213
68214   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68215   {
68216     try {
68217       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68218     } catch (std::out_of_range& e) {
68219       {
68220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68221       };
68222     } catch (std::exception& e) {
68223       {
68224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68225       };
68226     } catch (...) {
68227       {
68228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68229       };
68230     }
68231   }
68232   jresult = (void *)result;
68233   return jresult;
68234 }
68235
68236
68237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68238   void * jresult ;
68239   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68240   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68241
68242   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68243   {
68244     try {
68245       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68246     } catch (std::out_of_range& e) {
68247       {
68248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68249       };
68250     } catch (std::exception& e) {
68251       {
68252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68253       };
68254     } catch (...) {
68255       {
68256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68257       };
68258     }
68259   }
68260   jresult = (void *)result;
68261   return jresult;
68262 }
68263
68264
68265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68266   unsigned int jresult ;
68267   Dali::Toolkit::ControlOrientation::Type arg1 ;
68268   bool result;
68269
68270   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68271   {
68272     try {
68273       result = (bool)Dali::Toolkit::IsVertical(arg1);
68274     } catch (std::out_of_range& e) {
68275       {
68276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68277       };
68278     } catch (std::exception& e) {
68279       {
68280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68281       };
68282     } catch (...) {
68283       {
68284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68285       };
68286     }
68287   }
68288   jresult = result;
68289   return jresult;
68290 }
68291
68292
68293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68294   unsigned int jresult ;
68295   Dali::Toolkit::ControlOrientation::Type arg1 ;
68296   bool result;
68297
68298   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68299   {
68300     try {
68301       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68302     } catch (std::out_of_range& e) {
68303       {
68304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68305       };
68306     } catch (std::exception& e) {
68307       {
68308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68309       };
68310     } catch (...) {
68311       {
68312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68313       };
68314     }
68315   }
68316   jresult = result;
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68322   void * jresult ;
68323   unsigned int arg1 ;
68324   unsigned int arg2 ;
68325   Dali::Toolkit::ItemRange *result = 0 ;
68326
68327   arg1 = (unsigned int)jarg1;
68328   arg2 = (unsigned int)jarg2;
68329   {
68330     try {
68331       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68332     } catch (std::out_of_range& e) {
68333       {
68334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68335       };
68336     } catch (std::exception& e) {
68337       {
68338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68339       };
68340     } catch (...) {
68341       {
68342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68343       };
68344     }
68345   }
68346   jresult = (void *)result;
68347   return jresult;
68348 }
68349
68350
68351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68352   void * jresult ;
68353   Dali::Toolkit::ItemRange *arg1 = 0 ;
68354   Dali::Toolkit::ItemRange *result = 0 ;
68355
68356   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68357   if (!arg1) {
68358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68359     return 0;
68360   }
68361   {
68362     try {
68363       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68364     } catch (std::out_of_range& e) {
68365       {
68366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68367       };
68368     } catch (std::exception& e) {
68369       {
68370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68371       };
68372     } catch (...) {
68373       {
68374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68375       };
68376     }
68377   }
68378   jresult = (void *)result;
68379   return jresult;
68380 }
68381
68382
68383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68384   void * jresult ;
68385   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68386   Dali::Toolkit::ItemRange *arg2 = 0 ;
68387   Dali::Toolkit::ItemRange *result = 0 ;
68388
68389   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68390   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68391   if (!arg2) {
68392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68393     return 0;
68394   }
68395   {
68396     try {
68397       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68398     } catch (std::out_of_range& e) {
68399       {
68400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68401       };
68402     } catch (std::exception& e) {
68403       {
68404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68405       };
68406     } catch (...) {
68407       {
68408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68409       };
68410     }
68411   }
68412   jresult = (void *)result;
68413   return jresult;
68414 }
68415
68416
68417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68418   unsigned int jresult ;
68419   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68420   unsigned int arg2 ;
68421   bool result;
68422
68423   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68424   arg2 = (unsigned int)jarg2;
68425   {
68426     try {
68427       result = (bool)(arg1)->Within(arg2);
68428     } catch (std::out_of_range& e) {
68429       {
68430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68431       };
68432     } catch (std::exception& e) {
68433       {
68434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68435       };
68436     } catch (...) {
68437       {
68438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68439       };
68440     }
68441   }
68442   jresult = result;
68443   return jresult;
68444 }
68445
68446
68447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68448   void * jresult ;
68449   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68450   Dali::Toolkit::ItemRange *arg2 = 0 ;
68451   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68452
68453   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68454   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68455   if (!arg2) {
68456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68457     return 0;
68458   }
68459   {
68460     try {
68461       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68462     } catch (std::out_of_range& e) {
68463       {
68464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (std::exception& e) {
68467       {
68468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68469       };
68470     } catch (...) {
68471       {
68472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68473       };
68474     }
68475   }
68476   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68477   return jresult;
68478 }
68479
68480
68481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68482   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68483   unsigned int arg2 ;
68484
68485   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68486   arg2 = (unsigned int)jarg2;
68487   if (arg1) (arg1)->begin = arg2;
68488 }
68489
68490
68491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68492   unsigned int jresult ;
68493   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68494   unsigned int result;
68495
68496   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68497   result = (unsigned int) ((arg1)->begin);
68498   jresult = result;
68499   return jresult;
68500 }
68501
68502
68503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68504   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68505   unsigned int arg2 ;
68506
68507   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68508   arg2 = (unsigned int)jarg2;
68509   if (arg1) (arg1)->end = arg2;
68510 }
68511
68512
68513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68514   unsigned int jresult ;
68515   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68516   unsigned int result;
68517
68518   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68519   result = (unsigned int) ((arg1)->end);
68520   jresult = result;
68521   return jresult;
68522 }
68523
68524
68525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68526   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68527
68528   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68529   {
68530     try {
68531       delete arg1;
68532     } catch (std::out_of_range& e) {
68533       {
68534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68535       };
68536     } catch (std::exception& e) {
68537       {
68538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68543       };
68544     }
68545   }
68546 }
68547
68548
68549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68550   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68551
68552   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68553   {
68554     try {
68555       delete arg1;
68556     } catch (std::out_of_range& e) {
68557       {
68558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68559       };
68560     } catch (std::exception& e) {
68561       {
68562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68563       };
68564     } catch (...) {
68565       {
68566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68567       };
68568     }
68569   }
68570 }
68571
68572
68573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68574   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68575   Dali::Toolkit::ControlOrientation::Type arg2 ;
68576
68577   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68578   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68579   {
68580     try {
68581       (arg1)->SetOrientation(arg2);
68582     } catch (std::out_of_range& e) {
68583       {
68584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68585       };
68586     } catch (std::exception& e) {
68587       {
68588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68589       };
68590     } catch (...) {
68591       {
68592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68593       };
68594     }
68595   }
68596 }
68597
68598
68599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68600   int jresult ;
68601   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68602   Dali::Toolkit::ControlOrientation::Type result;
68603
68604   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68605   {
68606     try {
68607       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68608     } catch (std::out_of_range& e) {
68609       {
68610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68611       };
68612     } catch (std::exception& e) {
68613       {
68614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68615       };
68616     } catch (...) {
68617       {
68618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68619       };
68620     }
68621   }
68622   jresult = (int)result;
68623   return jresult;
68624 }
68625
68626
68627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68628   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68629   Dali::Property::Map *arg2 = 0 ;
68630
68631   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68632   arg2 = (Dali::Property::Map *)jarg2;
68633   if (!arg2) {
68634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68635     return ;
68636   }
68637   {
68638     try {
68639       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68640     } catch (std::out_of_range& e) {
68641       {
68642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68643       };
68644     } catch (std::exception& e) {
68645       {
68646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68647       };
68648     } catch (...) {
68649       {
68650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68651       };
68652     }
68653   }
68654 }
68655
68656
68657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68658   void * jresult ;
68659   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68660   Dali::Property::Map result;
68661
68662   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68663   {
68664     try {
68665       result = (arg1)->GetLayoutProperties();
68666     } catch (std::out_of_range& e) {
68667       {
68668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68669       };
68670     } catch (std::exception& e) {
68671       {
68672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68673       };
68674     } catch (...) {
68675       {
68676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68677       };
68678     }
68679   }
68680   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68681   return jresult;
68682 }
68683
68684
68685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68686   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68687   unsigned int arg2 ;
68688   Dali::Vector3 *arg3 = 0 ;
68689   Dali::Vector3 *arg4 = 0 ;
68690
68691   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68692   arg2 = (unsigned int)jarg2;
68693   arg3 = (Dali::Vector3 *)jarg3;
68694   if (!arg3) {
68695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68696     return ;
68697   }
68698   arg4 = (Dali::Vector3 *)jarg4;
68699   if (!arg4) {
68700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68701     return ;
68702   }
68703   {
68704     try {
68705       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68706     } catch (std::out_of_range& e) {
68707       {
68708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68709       };
68710     } catch (std::exception& e) {
68711       {
68712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68713       };
68714     } catch (...) {
68715       {
68716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68717       };
68718     }
68719   }
68720 }
68721
68722
68723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68724   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68725   Dali::Vector3 *arg2 = 0 ;
68726
68727   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68728   arg2 = (Dali::Vector3 *)jarg2;
68729   if (!arg2) {
68730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68731     return ;
68732   }
68733   {
68734     try {
68735       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68736     } catch (std::out_of_range& e) {
68737       {
68738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68739       };
68740     } catch (std::exception& e) {
68741       {
68742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68743       };
68744     } catch (...) {
68745       {
68746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68747       };
68748     }
68749   }
68750 }
68751
68752
68753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68754   float jresult ;
68755   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68756   unsigned int arg2 ;
68757   Dali::Vector3 arg3 ;
68758   Dali::Vector3 *argp3 ;
68759   float result;
68760
68761   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68762   arg2 = (unsigned int)jarg2;
68763   argp3 = (Dali::Vector3 *)jarg3;
68764   if (!argp3) {
68765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68766     return 0;
68767   }
68768   arg3 = *argp3;
68769   {
68770     try {
68771       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68772     } catch (std::out_of_range& e) {
68773       {
68774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (std::exception& e) {
68777       {
68778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786   jresult = result;
68787   return jresult;
68788 }
68789
68790
68791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68792   float jresult ;
68793   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68794   float arg2 ;
68795   float result;
68796
68797   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68798   arg2 = (float)jarg2;
68799   {
68800     try {
68801       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (...) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68813       };
68814     }
68815   }
68816   jresult = result;
68817   return jresult;
68818 }
68819
68820
68821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68822   float jresult ;
68823   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68824   unsigned int arg2 ;
68825   float result;
68826
68827   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68828   arg2 = (unsigned int)jarg2;
68829   {
68830     try {
68831       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68832     } catch (std::out_of_range& e) {
68833       {
68834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (std::exception& e) {
68837       {
68838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (...) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68843       };
68844     }
68845   }
68846   jresult = result;
68847   return jresult;
68848 }
68849
68850
68851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68852   void * jresult ;
68853   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68854   float arg2 ;
68855   Dali::Vector3 arg3 ;
68856   Dali::Vector3 *argp3 ;
68857   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68858
68859   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68860   arg2 = (float)jarg2;
68861   argp3 = (Dali::Vector3 *)jarg3;
68862   if (!argp3) {
68863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68864     return 0;
68865   }
68866   arg3 = *argp3;
68867   {
68868     try {
68869       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68870     } catch (std::out_of_range& e) {
68871       {
68872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68873       };
68874     } catch (std::exception& e) {
68875       {
68876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68877       };
68878     } catch (...) {
68879       {
68880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68881       };
68882     }
68883   }
68884   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68885   return jresult;
68886 }
68887
68888
68889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68890   float jresult ;
68891   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68892   int arg2 ;
68893   float arg3 ;
68894   Dali::Vector3 *arg4 = 0 ;
68895   float result;
68896
68897   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68898   arg2 = (int)jarg2;
68899   arg3 = (float)jarg3;
68900   arg4 = (Dali::Vector3 *)jarg4;
68901   if (!arg4) {
68902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68903     return 0;
68904   }
68905   {
68906     try {
68907       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68908     } catch (std::out_of_range& e) {
68909       {
68910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68911       };
68912     } catch (std::exception& e) {
68913       {
68914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68915       };
68916     } catch (...) {
68917       {
68918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68919       };
68920     }
68921   }
68922   jresult = result;
68923   return jresult;
68924 }
68925
68926
68927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68928   unsigned int jresult ;
68929   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68930   Dali::Vector3 arg2 ;
68931   Dali::Vector3 *argp2 ;
68932   unsigned int result;
68933
68934   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68935   argp2 = (Dali::Vector3 *)jarg2;
68936   if (!argp2) {
68937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68938     return 0;
68939   }
68940   arg2 = *argp2;
68941   {
68942     try {
68943       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68944     } catch (std::out_of_range& e) {
68945       {
68946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68947       };
68948     } catch (std::exception& e) {
68949       {
68950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68951       };
68952     } catch (...) {
68953       {
68954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68955       };
68956     }
68957   }
68958   jresult = result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68964   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68965   unsigned int arg2 ;
68966   Dali::Vector3 *arg3 = 0 ;
68967   Dali::Vector3 *arg4 = 0 ;
68968
68969   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68970   arg2 = (unsigned int)jarg2;
68971   arg3 = (Dali::Vector3 *)jarg3;
68972   if (!arg3) {
68973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68974     return ;
68975   }
68976   arg4 = (Dali::Vector3 *)jarg4;
68977   if (!arg4) {
68978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68979     return ;
68980   }
68981   {
68982     try {
68983       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68984     } catch (std::out_of_range& e) {
68985       {
68986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68987       };
68988     } catch (std::exception& e) {
68989       {
68990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68991       };
68992     } catch (...) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68995       };
68996     }
68997   }
68998 }
68999
69000
69001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69002   void * jresult ;
69003   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69004   Dali::Degree result;
69005
69006   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69007   {
69008     try {
69009       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69010     } catch (std::out_of_range& e) {
69011       {
69012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (std::exception& e) {
69015       {
69016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (...) {
69019       {
69020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69021       };
69022     }
69023   }
69024   jresult = new Dali::Degree((const Dali::Degree &)result);
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69030   float jresult ;
69031   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69032   float result;
69033
69034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69035   {
69036     try {
69037       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69038     } catch (std::out_of_range& e) {
69039       {
69040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69041       };
69042     } catch (std::exception& e) {
69043       {
69044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69045       };
69046     } catch (...) {
69047       {
69048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69049       };
69050     }
69051   }
69052   jresult = result;
69053   return jresult;
69054 }
69055
69056
69057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69058   float jresult ;
69059   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69060   float result;
69061
69062   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69063   {
69064     try {
69065       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69066     } catch (std::out_of_range& e) {
69067       {
69068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69069       };
69070     } catch (std::exception& e) {
69071       {
69072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69073       };
69074     } catch (...) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69077       };
69078     }
69079   }
69080   jresult = result;
69081   return jresult;
69082 }
69083
69084
69085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69086   float jresult ;
69087   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69088   float result;
69089
69090   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69091   {
69092     try {
69093       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69094     } catch (std::out_of_range& e) {
69095       {
69096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69097       };
69098     } catch (std::exception& e) {
69099       {
69100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69101       };
69102     } catch (...) {
69103       {
69104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69105       };
69106     }
69107   }
69108   jresult = result;
69109   return jresult;
69110 }
69111
69112
69113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69114   int jresult ;
69115   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69116   int arg2 ;
69117   int arg3 ;
69118   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69119   bool arg5 ;
69120   int result;
69121
69122   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69123   arg2 = (int)jarg2;
69124   arg3 = (int)jarg3;
69125   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69126   arg5 = jarg5 ? true : false;
69127   {
69128     try {
69129       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69130     } catch (std::out_of_range& e) {
69131       {
69132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69133       };
69134     } catch (std::exception& e) {
69135       {
69136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69137       };
69138     } catch (...) {
69139       {
69140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69141       };
69142     }
69143   }
69144   jresult = result;
69145   return jresult;
69146 }
69147
69148
69149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69150   float jresult ;
69151   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69152   float result;
69153
69154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69155   {
69156     try {
69157       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69158     } catch (std::out_of_range& e) {
69159       {
69160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69161       };
69162     } catch (std::exception& e) {
69163       {
69164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69165       };
69166     } catch (...) {
69167       {
69168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69169       };
69170     }
69171   }
69172   jresult = result;
69173   return jresult;
69174 }
69175
69176
69177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69178   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69179   Dali::Actor *arg2 = 0 ;
69180   int arg3 ;
69181   Dali::Vector3 *arg4 = 0 ;
69182   Dali::Actor *arg5 = 0 ;
69183
69184   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69185   arg2 = (Dali::Actor *)jarg2;
69186   if (!arg2) {
69187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69188     return ;
69189   }
69190   arg3 = (int)jarg3;
69191   arg4 = (Dali::Vector3 *)jarg4;
69192   if (!arg4) {
69193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69194     return ;
69195   }
69196   arg5 = (Dali::Actor *)jarg5;
69197   if (!arg5) {
69198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69199     return ;
69200   }
69201   {
69202     try {
69203       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69204     } catch (std::out_of_range& e) {
69205       {
69206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69207       };
69208     } catch (std::exception& e) {
69209       {
69210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69211       };
69212     } catch (...) {
69213       {
69214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69215       };
69216     }
69217   }
69218 }
69219
69220
69221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69222   void * jresult ;
69223   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69224   int arg2 ;
69225   float arg3 ;
69226   Dali::Vector3 *arg4 = 0 ;
69227   Dali::Vector3 result;
69228
69229   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69230   arg2 = (int)jarg2;
69231   arg3 = (float)jarg3;
69232   arg4 = (Dali::Vector3 *)jarg4;
69233   if (!arg4) {
69234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69235     return 0;
69236   }
69237   {
69238     try {
69239       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (...) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69251       };
69252     }
69253   }
69254   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69255   return jresult;
69256 }
69257
69258
69259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69260   void * jresult ;
69261   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69262   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69263
69264   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69265   {
69266     try {
69267       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69268     } catch (std::out_of_range& e) {
69269       {
69270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69271       };
69272     } catch (std::exception& e) {
69273       {
69274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (...) {
69277       {
69278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69279       };
69280     }
69281   }
69282   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69283   return jresult;
69284 }
69285
69286
69287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69288   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69289
69290   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69291   {
69292     try {
69293       delete arg1;
69294     } catch (std::out_of_range& e) {
69295       {
69296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69297       };
69298     } catch (std::exception& e) {
69299       {
69300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69301       };
69302     } catch (...) {
69303       {
69304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69305       };
69306     }
69307   }
69308 }
69309
69310
69311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69312   unsigned int jresult ;
69313   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69314   unsigned int result;
69315
69316   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69317   {
69318     try {
69319       result = (unsigned int)(arg1)->GetNumberOfItems();
69320     } catch (std::out_of_range& e) {
69321       {
69322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69323       };
69324     } catch (std::exception& e) {
69325       {
69326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69327       };
69328     } catch (...) {
69329       {
69330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69331       };
69332     }
69333   }
69334   jresult = result;
69335   return jresult;
69336 }
69337
69338
69339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69340   void * jresult ;
69341   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69342   unsigned int arg2 ;
69343   Dali::Actor result;
69344
69345   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69346   arg2 = (unsigned int)jarg2;
69347   {
69348     try {
69349       result = (arg1)->NewItem(arg2);
69350     } catch (std::out_of_range& e) {
69351       {
69352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69353       };
69354     } catch (std::exception& e) {
69355       {
69356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69357       };
69358     } catch (...) {
69359       {
69360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69361       };
69362     }
69363   }
69364   jresult = new Dali::Actor((const Dali::Actor &)result);
69365   return jresult;
69366 }
69367
69368
69369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69370   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69371   unsigned int arg2 ;
69372   Dali::Actor arg3 ;
69373   Dali::Actor *argp3 ;
69374
69375   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69376   arg2 = (unsigned int)jarg2;
69377   argp3 = (Dali::Actor *)jarg3;
69378   if (!argp3) {
69379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69380     return ;
69381   }
69382   arg3 = *argp3;
69383   {
69384     try {
69385       (arg1)->ItemReleased(arg2,arg3);
69386     } catch (std::out_of_range& e) {
69387       {
69388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69389       };
69390     } catch (std::exception& e) {
69391       {
69392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69393       };
69394     } catch (...) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69397       };
69398     }
69399   }
69400 }
69401
69402
69403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69404   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69405   unsigned int arg2 ;
69406   Dali::Actor arg3 ;
69407   Dali::Actor *argp3 ;
69408
69409   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69410   arg2 = (unsigned int)jarg2;
69411   argp3 = (Dali::Actor *)jarg3;
69412   if (!argp3) {
69413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69414     return ;
69415   }
69416   arg3 = *argp3;
69417   {
69418     try {
69419       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69420     } catch (std::out_of_range& e) {
69421       {
69422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69423       };
69424     } catch (std::exception& e) {
69425       {
69426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69427       };
69428     } catch (...) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69431       };
69432     }
69433   }
69434 }
69435
69436
69437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69438   void * jresult ;
69439   Dali::Toolkit::ItemFactory *result = 0 ;
69440
69441   {
69442     try {
69443       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69444     } catch (std::out_of_range& e) {
69445       {
69446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69447       };
69448     } catch (std::exception& e) {
69449       {
69450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69451       };
69452     } catch (...) {
69453       {
69454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69455       };
69456     }
69457   }
69458   jresult = (void *)result;
69459   return jresult;
69460 }
69461
69462
69463 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) {
69464   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69465   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69466   if (director) {
69467     director->swig_connect_director(callback0, callback1, callback2);
69468   }
69469 }
69470
69471
69472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69473   int jresult ;
69474   int result;
69475
69476   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69477   jresult = (int)result;
69478   return jresult;
69479 }
69480
69481
69482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69483   int jresult ;
69484   int result;
69485
69486   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69487   jresult = (int)result;
69488   return jresult;
69489 }
69490
69491
69492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69493   int jresult ;
69494   int result;
69495
69496   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69497   jresult = (int)result;
69498   return jresult;
69499 }
69500
69501
69502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69503   int jresult ;
69504   int result;
69505
69506   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69507   jresult = (int)result;
69508   return jresult;
69509 }
69510
69511
69512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69513   int jresult ;
69514   int result;
69515
69516   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69517   jresult = (int)result;
69518   return jresult;
69519 }
69520
69521
69522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69523   int jresult ;
69524   int result;
69525
69526   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69527   jresult = (int)result;
69528   return jresult;
69529 }
69530
69531
69532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69533   int jresult ;
69534   int result;
69535
69536   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69537   jresult = (int)result;
69538   return jresult;
69539 }
69540
69541
69542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69543   int jresult ;
69544   int result;
69545
69546   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69547   jresult = (int)result;
69548   return jresult;
69549 }
69550
69551
69552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69553   int jresult ;
69554   int result;
69555
69556   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69557   jresult = (int)result;
69558   return jresult;
69559 }
69560
69561
69562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69563   int jresult ;
69564   int result;
69565
69566   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69567   jresult = (int)result;
69568   return jresult;
69569 }
69570
69571
69572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69573   int jresult ;
69574   int result;
69575
69576   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69577   jresult = (int)result;
69578   return jresult;
69579 }
69580
69581
69582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69583   void * jresult ;
69584   Dali::Toolkit::ItemView::Property *result = 0 ;
69585
69586   {
69587     try {
69588       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69589     } catch (std::out_of_range& e) {
69590       {
69591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69592       };
69593     } catch (std::exception& e) {
69594       {
69595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69596       };
69597     } catch (...) {
69598       {
69599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69600       };
69601     }
69602   }
69603   jresult = (void *)result;
69604   return jresult;
69605 }
69606
69607
69608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69609   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69610
69611   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69612   {
69613     try {
69614       delete arg1;
69615     } catch (std::out_of_range& e) {
69616       {
69617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69618       };
69619     } catch (std::exception& e) {
69620       {
69621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69622       };
69623     } catch (...) {
69624       {
69625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69626       };
69627     }
69628   }
69629 }
69630
69631
69632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69633   void * jresult ;
69634   Dali::Toolkit::ItemView *result = 0 ;
69635
69636   {
69637     try {
69638       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69639     } catch (std::out_of_range& e) {
69640       {
69641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69642       };
69643     } catch (std::exception& e) {
69644       {
69645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69646       };
69647     } catch (...) {
69648       {
69649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69650       };
69651     }
69652   }
69653   jresult = (void *)result;
69654   return jresult;
69655 }
69656
69657
69658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69659   void * jresult ;
69660   Dali::Toolkit::ItemView *arg1 = 0 ;
69661   Dali::Toolkit::ItemView *result = 0 ;
69662
69663   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69664   if (!arg1) {
69665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69666     return 0;
69667   }
69668   {
69669     try {
69670       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (...) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69682       };
69683     }
69684   }
69685   jresult = (void *)result;
69686   return jresult;
69687 }
69688
69689
69690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69691   void * jresult ;
69692   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69693   Dali::Toolkit::ItemView *arg2 = 0 ;
69694   Dali::Toolkit::ItemView *result = 0 ;
69695
69696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69697   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69698   if (!arg2) {
69699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69700     return 0;
69701   }
69702   {
69703     try {
69704       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69705     } catch (std::out_of_range& e) {
69706       {
69707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (std::exception& e) {
69710       {
69711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (...) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69716       };
69717     }
69718   }
69719   jresult = (void *)result;
69720   return jresult;
69721 }
69722
69723
69724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69726
69727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69728   {
69729     try {
69730       delete arg1;
69731     } catch (std::out_of_range& e) {
69732       {
69733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69734       };
69735     } catch (std::exception& e) {
69736       {
69737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69738       };
69739     } catch (...) {
69740       {
69741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69742       };
69743     }
69744   }
69745 }
69746
69747
69748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69749   void * jresult ;
69750   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69751   Dali::Toolkit::ItemView result;
69752
69753   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69754   if (!arg1) {
69755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69756     return 0;
69757   }
69758   {
69759     try {
69760       result = Dali::Toolkit::ItemView::New(*arg1);
69761     } catch (std::out_of_range& e) {
69762       {
69763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69764       };
69765     } catch (std::exception& e) {
69766       {
69767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69768       };
69769     } catch (...) {
69770       {
69771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69772       };
69773     }
69774   }
69775   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69776   return jresult;
69777 }
69778
69779
69780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69781   void * jresult ;
69782   Dali::BaseHandle arg1 ;
69783   Dali::BaseHandle *argp1 ;
69784   Dali::Toolkit::ItemView result;
69785
69786   argp1 = (Dali::BaseHandle *)jarg1;
69787   if (!argp1) {
69788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69789     return 0;
69790   }
69791   arg1 = *argp1;
69792   {
69793     try {
69794       result = Dali::Toolkit::ItemView::DownCast(arg1);
69795     } catch (std::out_of_range& e) {
69796       {
69797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69798       };
69799     } catch (std::exception& e) {
69800       {
69801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (...) {
69804       {
69805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69806       };
69807     }
69808   }
69809   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69810   return jresult;
69811 }
69812
69813
69814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69815   unsigned int jresult ;
69816   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69817   unsigned int result;
69818
69819   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69820   {
69821     try {
69822       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69823     } catch (std::out_of_range& e) {
69824       {
69825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69826       };
69827     } catch (std::exception& e) {
69828       {
69829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (...) {
69832       {
69833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69834       };
69835     }
69836   }
69837   jresult = result;
69838   return jresult;
69839 }
69840
69841
69842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69844   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69845
69846   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69847   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69848   if (!arg2) {
69849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69850     return ;
69851   }
69852   {
69853     try {
69854       (arg1)->AddLayout(*arg2);
69855     } catch (std::out_of_range& e) {
69856       {
69857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69858       };
69859     } catch (std::exception& e) {
69860       {
69861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69862       };
69863     } catch (...) {
69864       {
69865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69866       };
69867     }
69868   }
69869 }
69870
69871
69872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69873   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69874   unsigned int arg2 ;
69875
69876   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69877   arg2 = (unsigned int)jarg2;
69878   {
69879     try {
69880       (arg1)->RemoveLayout(arg2);
69881     } catch (std::out_of_range& e) {
69882       {
69883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69884       };
69885     } catch (std::exception& e) {
69886       {
69887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69888       };
69889     } catch (...) {
69890       {
69891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69892       };
69893     }
69894   }
69895 }
69896
69897
69898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69899   void * jresult ;
69900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69901   unsigned int arg2 ;
69902   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69903
69904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69905   arg2 = (unsigned int)jarg2;
69906   {
69907     try {
69908       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69909     } catch (std::out_of_range& e) {
69910       {
69911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (std::exception& e) {
69914       {
69915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (...) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69920       };
69921     }
69922   }
69923   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69924   return jresult;
69925 }
69926
69927
69928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69929   void * jresult ;
69930   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69931   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69932
69933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69934   {
69935     try {
69936       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69937     } catch (std::out_of_range& e) {
69938       {
69939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69940       };
69941     } catch (std::exception& e) {
69942       {
69943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69944       };
69945     } catch (...) {
69946       {
69947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69948       };
69949     }
69950   }
69951   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69952   return jresult;
69953 }
69954
69955
69956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69957   float jresult ;
69958   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69959   Dali::Toolkit::ItemId arg2 ;
69960   float result;
69961
69962   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69963   arg2 = (Dali::Toolkit::ItemId)jarg2;
69964   {
69965     try {
69966       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69967     } catch (std::out_of_range& e) {
69968       {
69969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69970       };
69971     } catch (std::exception& e) {
69972       {
69973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69974       };
69975     } catch (...) {
69976       {
69977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69978       };
69979     }
69980   }
69981   jresult = result;
69982   return jresult;
69983 }
69984
69985
69986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69987   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69988   unsigned int arg2 ;
69989   Dali::Vector3 arg3 ;
69990   float arg4 ;
69991   Dali::Vector3 *argp3 ;
69992
69993   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69994   arg2 = (unsigned int)jarg2;
69995   argp3 = (Dali::Vector3 *)jarg3;
69996   if (!argp3) {
69997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69998     return ;
69999   }
70000   arg3 = *argp3;
70001   arg4 = (float)jarg4;
70002   {
70003     try {
70004       (arg1)->ActivateLayout(arg2,arg3,arg4);
70005     } catch (std::out_of_range& e) {
70006       {
70007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70008       };
70009     } catch (std::exception& e) {
70010       {
70011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70012       };
70013     } catch (...) {
70014       {
70015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70016       };
70017     }
70018   }
70019 }
70020
70021
70022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70023   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70024
70025   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70026   {
70027     try {
70028       (arg1)->DeactivateCurrentLayout();
70029     } catch (std::out_of_range& e) {
70030       {
70031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70032       };
70033     } catch (std::exception& e) {
70034       {
70035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70036       };
70037     } catch (...) {
70038       {
70039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70040       };
70041     }
70042   }
70043 }
70044
70045
70046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70047   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70048   float arg2 ;
70049
70050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70051   arg2 = (float)jarg2;
70052   {
70053     try {
70054       (arg1)->SetMinimumSwipeSpeed(arg2);
70055     } catch (std::out_of_range& e) {
70056       {
70057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70058       };
70059     } catch (std::exception& e) {
70060       {
70061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70062       };
70063     } catch (...) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70066       };
70067     }
70068   }
70069 }
70070
70071
70072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70073   float jresult ;
70074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70075   float result;
70076
70077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70078   {
70079     try {
70080       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70081     } catch (std::out_of_range& e) {
70082       {
70083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (std::exception& e) {
70086       {
70087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (...) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70092       };
70093     }
70094   }
70095   jresult = result;
70096   return jresult;
70097 }
70098
70099
70100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70101   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70102   float arg2 ;
70103
70104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70105   arg2 = (float)jarg2;
70106   {
70107     try {
70108       (arg1)->SetMinimumSwipeDistance(arg2);
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70120       };
70121     }
70122   }
70123 }
70124
70125
70126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70127   float jresult ;
70128   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70129   float result;
70130
70131   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70132   {
70133     try {
70134       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70135     } catch (std::out_of_range& e) {
70136       {
70137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70138       };
70139     } catch (std::exception& e) {
70140       {
70141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (...) {
70144       {
70145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70146       };
70147     }
70148   }
70149   jresult = result;
70150   return jresult;
70151 }
70152
70153
70154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70155   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70156   float arg2 ;
70157
70158   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70159   arg2 = (float)jarg2;
70160   {
70161     try {
70162       (arg1)->SetWheelScrollDistanceStep(arg2);
70163     } catch (std::out_of_range& e) {
70164       {
70165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70166       };
70167     } catch (std::exception& e) {
70168       {
70169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70170       };
70171     } catch (...) {
70172       {
70173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70174       };
70175     }
70176   }
70177 }
70178
70179
70180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70181   float jresult ;
70182   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70183   float result;
70184
70185   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70186   {
70187     try {
70188       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70189     } catch (std::out_of_range& e) {
70190       {
70191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70192       };
70193     } catch (std::exception& e) {
70194       {
70195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (...) {
70198       {
70199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70200       };
70201     }
70202   }
70203   jresult = result;
70204   return jresult;
70205 }
70206
70207
70208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70209   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70210   bool arg2 ;
70211
70212   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70213   arg2 = jarg2 ? true : false;
70214   {
70215     try {
70216       (arg1)->SetAnchoring(arg2);
70217     } catch (std::out_of_range& e) {
70218       {
70219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70220       };
70221     } catch (std::exception& e) {
70222       {
70223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (...) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70228       };
70229     }
70230   }
70231 }
70232
70233
70234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70235   unsigned int jresult ;
70236   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70237   bool result;
70238
70239   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70240   {
70241     try {
70242       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70243     } catch (std::out_of_range& e) {
70244       {
70245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70246       };
70247     } catch (std::exception& e) {
70248       {
70249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70250       };
70251     } catch (...) {
70252       {
70253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70254       };
70255     }
70256   }
70257   jresult = result;
70258   return jresult;
70259 }
70260
70261
70262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70263   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70264   float arg2 ;
70265
70266   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70267   arg2 = (float)jarg2;
70268   {
70269     try {
70270       (arg1)->SetAnchoringDuration(arg2);
70271     } catch (std::out_of_range& e) {
70272       {
70273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70274       };
70275     } catch (std::exception& e) {
70276       {
70277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70278       };
70279     } catch (...) {
70280       {
70281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70282       };
70283     }
70284   }
70285 }
70286
70287
70288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70289   float jresult ;
70290   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70291   float result;
70292
70293   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70294   {
70295     try {
70296       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70297     } catch (std::out_of_range& e) {
70298       {
70299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (std::exception& e) {
70302       {
70303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70304       };
70305     } catch (...) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70308       };
70309     }
70310   }
70311   jresult = result;
70312   return jresult;
70313 }
70314
70315
70316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70317   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70318   Dali::Toolkit::ItemId arg2 ;
70319   float arg3 ;
70320
70321   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70322   arg2 = (Dali::Toolkit::ItemId)jarg2;
70323   arg3 = (float)jarg3;
70324   {
70325     try {
70326       (arg1)->ScrollToItem(arg2,arg3);
70327     } catch (std::out_of_range& e) {
70328       {
70329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70330       };
70331     } catch (std::exception& e) {
70332       {
70333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70334       };
70335     } catch (...) {
70336       {
70337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70338       };
70339     }
70340   }
70341 }
70342
70343
70344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70346   float arg2 ;
70347
70348   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70349   arg2 = (float)jarg2;
70350   {
70351     try {
70352       (arg1)->SetRefreshInterval(arg2);
70353     } catch (std::out_of_range& e) {
70354       {
70355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70356       };
70357     } catch (std::exception& e) {
70358       {
70359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70360       };
70361     } catch (...) {
70362       {
70363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70364       };
70365     }
70366   }
70367 }
70368
70369
70370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70371   float jresult ;
70372   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70373   float result;
70374
70375   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70376   {
70377     try {
70378       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70379     } catch (std::out_of_range& e) {
70380       {
70381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (std::exception& e) {
70384       {
70385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (...) {
70388       {
70389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70390       };
70391     }
70392   }
70393   jresult = result;
70394   return jresult;
70395 }
70396
70397
70398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70399   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70400
70401   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70402   {
70403     try {
70404       (arg1)->Refresh();
70405     } catch (std::out_of_range& e) {
70406       {
70407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70408       };
70409     } catch (std::exception& e) {
70410       {
70411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70412       };
70413     } catch (...) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70416       };
70417     }
70418   }
70419 }
70420
70421
70422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70423   void * jresult ;
70424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70425   Dali::Toolkit::ItemId arg2 ;
70426   Dali::Actor result;
70427
70428   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70429   arg2 = (Dali::Toolkit::ItemId)jarg2;
70430   {
70431     try {
70432       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70433     } catch (std::out_of_range& e) {
70434       {
70435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70436       };
70437     } catch (std::exception& e) {
70438       {
70439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70444       };
70445     }
70446   }
70447   jresult = new Dali::Actor((const Dali::Actor &)result);
70448   return jresult;
70449 }
70450
70451
70452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70453   unsigned int jresult ;
70454   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70455   Dali::Actor arg2 ;
70456   Dali::Actor *argp2 ;
70457   Dali::Toolkit::ItemId result;
70458
70459   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70460   argp2 = (Dali::Actor *)jarg2;
70461   if (!argp2) {
70462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70463     return 0;
70464   }
70465   arg2 = *argp2;
70466   {
70467     try {
70468       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70469     } catch (std::out_of_range& e) {
70470       {
70471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70472       };
70473     } catch (std::exception& e) {
70474       {
70475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70476       };
70477     } catch (...) {
70478       {
70479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70480       };
70481     }
70482   }
70483   jresult = result;
70484   return jresult;
70485 }
70486
70487
70488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70490   Dali::Toolkit::Item arg2 ;
70491   float arg3 ;
70492   Dali::Toolkit::Item *argp2 ;
70493
70494   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70495   argp2 = (Dali::Toolkit::Item *)jarg2;
70496   if (!argp2) {
70497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70498     return ;
70499   }
70500   arg2 = *argp2;
70501   arg3 = (float)jarg3;
70502   {
70503     try {
70504       (arg1)->InsertItem(arg2,arg3);
70505     } catch (std::out_of_range& e) {
70506       {
70507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70508       };
70509     } catch (std::exception& e) {
70510       {
70511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (...) {
70514       {
70515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70516       };
70517     }
70518   }
70519 }
70520
70521
70522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70523   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70524   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70525   float arg3 ;
70526
70527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70528   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70529   if (!arg2) {
70530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70531     return ;
70532   }
70533   arg3 = (float)jarg3;
70534   {
70535     try {
70536       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70537     } catch (std::out_of_range& e) {
70538       {
70539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (std::exception& e) {
70542       {
70543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70548       };
70549     }
70550   }
70551 }
70552
70553
70554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70555   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70556   Dali::Toolkit::ItemId arg2 ;
70557   float arg3 ;
70558
70559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70560   arg2 = (Dali::Toolkit::ItemId)jarg2;
70561   arg3 = (float)jarg3;
70562   {
70563     try {
70564       (arg1)->RemoveItem(arg2,arg3);
70565     } catch (std::out_of_range& e) {
70566       {
70567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (std::exception& e) {
70570       {
70571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (...) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70576       };
70577     }
70578   }
70579 }
70580
70581
70582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70583   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70584   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70585   float arg3 ;
70586
70587   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70588   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70589   if (!arg2) {
70590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70591     return ;
70592   }
70593   arg3 = (float)jarg3;
70594   {
70595     try {
70596       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70597     } catch (std::out_of_range& e) {
70598       {
70599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70600       };
70601     } catch (std::exception& e) {
70602       {
70603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70604       };
70605     } catch (...) {
70606       {
70607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70608       };
70609     }
70610   }
70611 }
70612
70613
70614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70615   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70616   Dali::Toolkit::Item arg2 ;
70617   float arg3 ;
70618   Dali::Toolkit::Item *argp2 ;
70619
70620   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70621   argp2 = (Dali::Toolkit::Item *)jarg2;
70622   if (!argp2) {
70623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70624     return ;
70625   }
70626   arg2 = *argp2;
70627   arg3 = (float)jarg3;
70628   {
70629     try {
70630       (arg1)->ReplaceItem(arg2,arg3);
70631     } catch (std::out_of_range& e) {
70632       {
70633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70634       };
70635     } catch (std::exception& e) {
70636       {
70637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70638       };
70639     } catch (...) {
70640       {
70641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70642       };
70643     }
70644   }
70645 }
70646
70647
70648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70649   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70650   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70651   float arg3 ;
70652
70653   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70654   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70655   if (!arg2) {
70656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70657     return ;
70658   }
70659   arg3 = (float)jarg3;
70660   {
70661     try {
70662       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70663     } catch (std::out_of_range& e) {
70664       {
70665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70666       };
70667     } catch (std::exception& e) {
70668       {
70669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70670       };
70671     } catch (...) {
70672       {
70673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70674       };
70675     }
70676   }
70677 }
70678
70679
70680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70681   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70682   Dali::Vector3 *arg2 = 0 ;
70683
70684   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70685   arg2 = (Dali::Vector3 *)jarg2;
70686   if (!arg2) {
70687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70688     return ;
70689   }
70690   {
70691     try {
70692       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70693     } catch (std::out_of_range& e) {
70694       {
70695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70696       };
70697     } catch (std::exception& e) {
70698       {
70699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70700       };
70701     } catch (...) {
70702       {
70703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70704       };
70705     }
70706   }
70707 }
70708
70709
70710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70711   void * jresult ;
70712   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70713   Dali::Vector3 result;
70714
70715   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70716   {
70717     try {
70718       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70719     } catch (std::out_of_range& e) {
70720       {
70721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70722       };
70723     } catch (std::exception& e) {
70724       {
70725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70726       };
70727     } catch (...) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70730       };
70731     }
70732   }
70733   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70734   return jresult;
70735 }
70736
70737
70738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70739   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70740   Dali::Vector3 *arg2 = 0 ;
70741
70742   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70743   arg2 = (Dali::Vector3 *)jarg2;
70744   if (!arg2) {
70745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70746     return ;
70747   }
70748   {
70749     try {
70750       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70751     } catch (std::out_of_range& e) {
70752       {
70753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70754       };
70755     } catch (std::exception& e) {
70756       {
70757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70758       };
70759     } catch (...) {
70760       {
70761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70762       };
70763     }
70764   }
70765 }
70766
70767
70768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70769   void * jresult ;
70770   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70771   Dali::Vector3 result;
70772
70773   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70774   {
70775     try {
70776       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70777     } catch (std::out_of_range& e) {
70778       {
70779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70780       };
70781     } catch (std::exception& e) {
70782       {
70783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70784       };
70785     } catch (...) {
70786       {
70787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70788       };
70789     }
70790   }
70791   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70792   return jresult;
70793 }
70794
70795
70796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70798   Dali::Toolkit::ItemRange *arg2 = 0 ;
70799
70800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70801   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70802   if (!arg2) {
70803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70804     return ;
70805   }
70806   {
70807     try {
70808       (arg1)->GetItemsRange(*arg2);
70809     } catch (std::out_of_range& e) {
70810       {
70811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70812       };
70813     } catch (std::exception& e) {
70814       {
70815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70816       };
70817     } catch (...) {
70818       {
70819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70820       };
70821     }
70822   }
70823 }
70824
70825
70826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70827   void * jresult ;
70828   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70829   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70830
70831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70832   {
70833     try {
70834       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70835     } catch (std::out_of_range& e) {
70836       {
70837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70838       };
70839     } catch (std::exception& e) {
70840       {
70841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70842       };
70843     } catch (...) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70846       };
70847     }
70848   }
70849   jresult = (void *)result;
70850   return jresult;
70851 }
70852
70853
70854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70855   Dali::Vector3 *arg1 = 0 ;
70856   PropertyInputContainer *arg2 = 0 ;
70857
70858   arg1 = (Dali::Vector3 *)jarg1;
70859   if (!arg1) {
70860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70861     return ;
70862   }
70863   arg2 = (PropertyInputContainer *)jarg2;
70864   if (!arg2) {
70865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70866     return ;
70867   }
70868   {
70869     try {
70870       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70871     } catch (std::out_of_range& e) {
70872       {
70873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70874       };
70875     } catch (std::exception& e) {
70876       {
70877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70878       };
70879     } catch (...) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70882       };
70883     }
70884   }
70885 }
70886
70887
70888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70889   Dali::Vector3 *arg1 = 0 ;
70890   PropertyInputContainer *arg2 = 0 ;
70891
70892   arg1 = (Dali::Vector3 *)jarg1;
70893   if (!arg1) {
70894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70895     return ;
70896   }
70897   arg2 = (PropertyInputContainer *)jarg2;
70898   if (!arg2) {
70899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70900     return ;
70901   }
70902   {
70903     try {
70904       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (...) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70916       };
70917     }
70918   }
70919 }
70920
70921
70922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70923   void * jresult ;
70924   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70925
70926   {
70927     try {
70928       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70929     } catch (std::out_of_range& e) {
70930       {
70931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70932       };
70933     } catch (std::exception& e) {
70934       {
70935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70936       };
70937     } catch (...) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70940       };
70941     }
70942   }
70943   jresult = (void *)result;
70944   return jresult;
70945 }
70946
70947
70948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70949   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70950
70951   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70952   {
70953     try {
70954       delete arg1;
70955     } catch (std::out_of_range& e) {
70956       {
70957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70958       };
70959     } catch (std::exception& e) {
70960       {
70961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70962       };
70963     } catch (...) {
70964       {
70965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70966       };
70967     }
70968   }
70969 }
70970
70971
70972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70973   void * jresult ;
70974   Dali::Path arg1 ;
70975   Dali::Vector3 *arg2 = 0 ;
70976   Dali::Property::Index arg3 ;
70977   Dali::Vector3 *arg4 = 0 ;
70978   unsigned int arg5 ;
70979   Dali::Path *argp1 ;
70980   Dali::Toolkit::ScrollViewPagePathEffect result;
70981
70982   argp1 = (Dali::Path *)jarg1;
70983   if (!argp1) {
70984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70985     return 0;
70986   }
70987   arg1 = *argp1;
70988   arg2 = (Dali::Vector3 *)jarg2;
70989   if (!arg2) {
70990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70991     return 0;
70992   }
70993   arg3 = (Dali::Property::Index)jarg3;
70994   arg4 = (Dali::Vector3 *)jarg4;
70995   if (!arg4) {
70996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70997     return 0;
70998   }
70999   arg5 = (unsigned int)jarg5;
71000   {
71001     try {
71002       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71003     } catch (std::out_of_range& e) {
71004       {
71005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71006       };
71007     } catch (std::exception& e) {
71008       {
71009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71010       };
71011     } catch (...) {
71012       {
71013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71014       };
71015     }
71016   }
71017   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71018   return jresult;
71019 }
71020
71021
71022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71023   void * jresult ;
71024   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71025
71026   {
71027     try {
71028       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71029     } catch (std::out_of_range& e) {
71030       {
71031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71032       };
71033     } catch (std::exception& e) {
71034       {
71035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71036       };
71037     } catch (...) {
71038       {
71039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71040       };
71041     }
71042   }
71043   jresult = (void *)result;
71044   return jresult;
71045 }
71046
71047
71048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71049   void * jresult ;
71050   Dali::BaseHandle arg1 ;
71051   Dali::BaseHandle *argp1 ;
71052   Dali::Toolkit::ScrollViewPagePathEffect result;
71053
71054   argp1 = (Dali::BaseHandle *)jarg1;
71055   if (!argp1) {
71056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71057     return 0;
71058   }
71059   arg1 = *argp1;
71060   {
71061     try {
71062       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71063     } catch (std::out_of_range& e) {
71064       {
71065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71066       };
71067     } catch (std::exception& e) {
71068       {
71069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71070       };
71071     } catch (...) {
71072       {
71073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71074       };
71075     }
71076   }
71077   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71078   return jresult;
71079 }
71080
71081
71082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71083   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71084   Dali::Actor arg2 ;
71085   unsigned int arg3 ;
71086   Dali::Actor *argp2 ;
71087
71088   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71089   argp2 = (Dali::Actor *)jarg2;
71090   if (!argp2) {
71091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71092     return ;
71093   }
71094   arg2 = *argp2;
71095   arg3 = (unsigned int)jarg3;
71096   {
71097     try {
71098       (arg1)->ApplyToPage(arg2,arg3);
71099     } catch (std::out_of_range& e) {
71100       {
71101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71102       };
71103     } catch (std::exception& e) {
71104       {
71105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71106       };
71107     } catch (...) {
71108       {
71109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71110       };
71111     }
71112   }
71113 }
71114
71115
71116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71117   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71118
71119   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71120   {
71121     try {
71122       delete arg1;
71123     } catch (std::out_of_range& e) {
71124       {
71125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71126       };
71127     } catch (std::exception& e) {
71128       {
71129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71130       };
71131     } catch (...) {
71132       {
71133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71134       };
71135     }
71136   }
71137 }
71138
71139
71140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71141   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71142   Dali::Toolkit::ClampState arg2 ;
71143
71144   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71145   arg2 = (Dali::Toolkit::ClampState)jarg2;
71146   if (arg1) (arg1)->x = arg2;
71147 }
71148
71149
71150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71151   int jresult ;
71152   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71153   Dali::Toolkit::ClampState result;
71154
71155   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71156   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71157   jresult = (int)result;
71158   return jresult;
71159 }
71160
71161
71162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71163   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71164   Dali::Toolkit::ClampState arg2 ;
71165
71166   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71167   arg2 = (Dali::Toolkit::ClampState)jarg2;
71168   if (arg1) (arg1)->y = arg2;
71169 }
71170
71171
71172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71173   int jresult ;
71174   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71175   Dali::Toolkit::ClampState result;
71176
71177   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71178   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71179   jresult = (int)result;
71180   return jresult;
71181 }
71182
71183
71184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71185   void * jresult ;
71186   Dali::Toolkit::ClampState2D *result = 0 ;
71187
71188   {
71189     try {
71190       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71191     } catch (std::out_of_range& e) {
71192       {
71193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71194       };
71195     } catch (std::exception& e) {
71196       {
71197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71198       };
71199     } catch (...) {
71200       {
71201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71202       };
71203     }
71204   }
71205   jresult = (void *)result;
71206   return jresult;
71207 }
71208
71209
71210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71211   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71212
71213   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71214   {
71215     try {
71216       delete arg1;
71217     } catch (std::out_of_range& e) {
71218       {
71219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71220       };
71221     } catch (std::exception& e) {
71222       {
71223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71228       };
71229     }
71230   }
71231 }
71232
71233
71234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71235   void * jresult ;
71236   float arg1 ;
71237   float arg2 ;
71238   bool arg3 ;
71239   Dali::Toolkit::RulerDomain *result = 0 ;
71240
71241   arg1 = (float)jarg1;
71242   arg2 = (float)jarg2;
71243   arg3 = jarg3 ? true : false;
71244   {
71245     try {
71246       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71247     } catch (std::out_of_range& e) {
71248       {
71249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71250       };
71251     } catch (std::exception& e) {
71252       {
71253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71254       };
71255     } catch (...) {
71256       {
71257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71258       };
71259     }
71260   }
71261   jresult = (void *)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71267   void * jresult ;
71268   float arg1 ;
71269   float arg2 ;
71270   Dali::Toolkit::RulerDomain *result = 0 ;
71271
71272   arg1 = (float)jarg1;
71273   arg2 = (float)jarg2;
71274   {
71275     try {
71276       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71277     } catch (std::out_of_range& e) {
71278       {
71279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71280       };
71281     } catch (std::exception& e) {
71282       {
71283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71284       };
71285     } catch (...) {
71286       {
71287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71288       };
71289     }
71290   }
71291   jresult = (void *)result;
71292   return jresult;
71293 }
71294
71295
71296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71297   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71298   float arg2 ;
71299
71300   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71301   arg2 = (float)jarg2;
71302   if (arg1) (arg1)->min = arg2;
71303 }
71304
71305
71306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71307   float jresult ;
71308   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71309   float result;
71310
71311   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71312   result = (float) ((arg1)->min);
71313   jresult = result;
71314   return jresult;
71315 }
71316
71317
71318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71319   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71320   float arg2 ;
71321
71322   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71323   arg2 = (float)jarg2;
71324   if (arg1) (arg1)->max = arg2;
71325 }
71326
71327
71328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71329   float jresult ;
71330   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71331   float result;
71332
71333   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71334   result = (float) ((arg1)->max);
71335   jresult = result;
71336   return jresult;
71337 }
71338
71339
71340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71341   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71342   bool arg2 ;
71343
71344   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71345   arg2 = jarg2 ? true : false;
71346   if (arg1) (arg1)->enabled = arg2;
71347 }
71348
71349
71350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71351   unsigned int jresult ;
71352   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71353   bool result;
71354
71355   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71356   result = (bool) ((arg1)->enabled);
71357   jresult = result;
71358   return jresult;
71359 }
71360
71361
71362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71363   float jresult ;
71364   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71365   float arg2 ;
71366   float arg3 ;
71367   float arg4 ;
71368   float result;
71369
71370   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71371   arg2 = (float)jarg2;
71372   arg3 = (float)jarg3;
71373   arg4 = (float)jarg4;
71374   {
71375     try {
71376       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71377     } catch (std::out_of_range& e) {
71378       {
71379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71380       };
71381     } catch (std::exception& e) {
71382       {
71383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71384       };
71385     } catch (...) {
71386       {
71387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71388       };
71389     }
71390   }
71391   jresult = result;
71392   return jresult;
71393 }
71394
71395
71396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71397   float jresult ;
71398   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71399   float arg2 ;
71400   float arg3 ;
71401   float result;
71402
71403   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71404   arg2 = (float)jarg2;
71405   arg3 = (float)jarg3;
71406   {
71407     try {
71408       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71409     } catch (std::out_of_range& e) {
71410       {
71411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71412       };
71413     } catch (std::exception& e) {
71414       {
71415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71416       };
71417     } catch (...) {
71418       {
71419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71420       };
71421     }
71422   }
71423   jresult = result;
71424   return jresult;
71425 }
71426
71427
71428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71429   float jresult ;
71430   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71431   float arg2 ;
71432   float result;
71433
71434   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71435   arg2 = (float)jarg2;
71436   {
71437     try {
71438       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71439     } catch (std::out_of_range& e) {
71440       {
71441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71442       };
71443     } catch (std::exception& e) {
71444       {
71445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71446       };
71447     } catch (...) {
71448       {
71449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71450       };
71451     }
71452   }
71453   jresult = result;
71454   return jresult;
71455 }
71456
71457
71458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71459   float jresult ;
71460   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71461   float arg2 ;
71462   float arg3 ;
71463   float arg4 ;
71464   Dali::Toolkit::ClampState *arg5 = 0 ;
71465   float result;
71466
71467   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71468   arg2 = (float)jarg2;
71469   arg3 = (float)jarg3;
71470   arg4 = (float)jarg4;
71471   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71472   if (!arg5) {
71473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71474     return 0;
71475   }
71476   {
71477     try {
71478       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71479     } catch (std::out_of_range& e) {
71480       {
71481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71482       };
71483     } catch (std::exception& e) {
71484       {
71485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71486       };
71487     } catch (...) {
71488       {
71489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71490       };
71491     }
71492   }
71493   jresult = result;
71494   return jresult;
71495 }
71496
71497
71498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71499   float jresult ;
71500   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71501   float result;
71502
71503   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71504   {
71505     try {
71506       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71507     } catch (std::out_of_range& e) {
71508       {
71509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71510       };
71511     } catch (std::exception& e) {
71512       {
71513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71518       };
71519     }
71520   }
71521   jresult = result;
71522   return jresult;
71523 }
71524
71525
71526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71527   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71528
71529   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71530   {
71531     try {
71532       delete arg1;
71533     } catch (std::out_of_range& e) {
71534       {
71535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (std::exception& e) {
71538       {
71539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71540       };
71541     } catch (...) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71544       };
71545     }
71546   }
71547 }
71548
71549
71550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71551   float jresult ;
71552   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71553   float arg2 ;
71554   float arg3 ;
71555   float result;
71556
71557   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71558   arg2 = (float)jarg2;
71559   arg3 = (float)jarg3;
71560   {
71561     try {
71562       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71563     } catch (std::out_of_range& e) {
71564       {
71565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71566       };
71567     } catch (std::exception& e) {
71568       {
71569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71570       };
71571     } catch (...) {
71572       {
71573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71574       };
71575     }
71576   }
71577   jresult = result;
71578   return jresult;
71579 }
71580
71581
71582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71583   float jresult ;
71584   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71585   float arg2 ;
71586   float result;
71587
71588   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71589   arg2 = (float)jarg2;
71590   {
71591     try {
71592       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71593     } catch (std::out_of_range& e) {
71594       {
71595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71596       };
71597     } catch (std::exception& e) {
71598       {
71599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71600       };
71601     } catch (...) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71604       };
71605     }
71606   }
71607   jresult = result;
71608   return jresult;
71609 }
71610
71611
71612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71613   float jresult ;
71614   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71615   unsigned int arg2 ;
71616   unsigned int *arg3 = 0 ;
71617   bool arg4 ;
71618   float result;
71619
71620   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71621   arg2 = (unsigned int)jarg2;
71622   arg3 = (unsigned int *)jarg3;
71623   arg4 = jarg4 ? true : false;
71624   {
71625     try {
71626       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71627     } catch (std::out_of_range& e) {
71628       {
71629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71630       };
71631     } catch (std::exception& e) {
71632       {
71633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (...) {
71636       {
71637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71638       };
71639     }
71640   }
71641   jresult = result;
71642   return jresult;
71643 }
71644
71645
71646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71647   unsigned int jresult ;
71648   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71649   float arg2 ;
71650   bool arg3 ;
71651   unsigned int result;
71652
71653   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71654   arg2 = (float)jarg2;
71655   arg3 = jarg3 ? true : false;
71656   {
71657     try {
71658       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71659     } catch (std::out_of_range& e) {
71660       {
71661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71662       };
71663     } catch (std::exception& e) {
71664       {
71665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71666       };
71667     } catch (...) {
71668       {
71669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71670       };
71671     }
71672   }
71673   jresult = result;
71674   return jresult;
71675 }
71676
71677
71678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71679   unsigned int jresult ;
71680   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71681   unsigned int result;
71682
71683   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71684   {
71685     try {
71686       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71687     } catch (std::out_of_range& e) {
71688       {
71689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71690       };
71691     } catch (std::exception& e) {
71692       {
71693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71694       };
71695     } catch (...) {
71696       {
71697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71698       };
71699     }
71700   }
71701   jresult = result;
71702   return jresult;
71703 }
71704
71705
71706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71707   int jresult ;
71708   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71709   Dali::Toolkit::Ruler::RulerType result;
71710
71711   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71712   {
71713     try {
71714       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71715     } catch (std::out_of_range& e) {
71716       {
71717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71718       };
71719     } catch (std::exception& e) {
71720       {
71721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71722       };
71723     } catch (...) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71726       };
71727     }
71728   }
71729   jresult = (int)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71735   unsigned int jresult ;
71736   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71737   bool result;
71738
71739   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71740   {
71741     try {
71742       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71743     } catch (std::out_of_range& e) {
71744       {
71745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71746       };
71747     } catch (std::exception& e) {
71748       {
71749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71750       };
71751     } catch (...) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71754       };
71755     }
71756   }
71757   jresult = result;
71758   return jresult;
71759 }
71760
71761
71762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71763   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71764
71765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71766   {
71767     try {
71768       (arg1)->Enable();
71769     } catch (std::out_of_range& e) {
71770       {
71771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71772       };
71773     } catch (std::exception& e) {
71774       {
71775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71776       };
71777     } catch (...) {
71778       {
71779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71780       };
71781     }
71782   }
71783 }
71784
71785
71786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71787   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71788
71789   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71790   {
71791     try {
71792       (arg1)->Disable();
71793     } catch (std::out_of_range& e) {
71794       {
71795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71796       };
71797     } catch (std::exception& e) {
71798       {
71799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71800       };
71801     } catch (...) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71804       };
71805     }
71806   }
71807 }
71808
71809
71810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71811   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71812   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71813   Dali::Toolkit::RulerDomain *argp2 ;
71814
71815   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71816   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71817   if (!argp2) {
71818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71819     return ;
71820   }
71821   arg2 = *argp2;
71822   {
71823     try {
71824       (arg1)->SetDomain(arg2);
71825     } catch (std::out_of_range& e) {
71826       {
71827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71828       };
71829     } catch (std::exception& e) {
71830       {
71831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71832       };
71833     } catch (...) {
71834       {
71835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71836       };
71837     }
71838   }
71839 }
71840
71841
71842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71843   void * jresult ;
71844   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71845   Dali::Toolkit::RulerDomain *result = 0 ;
71846
71847   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71848   {
71849     try {
71850       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (...) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71862       };
71863     }
71864   }
71865   jresult = (void *)result;
71866   return jresult;
71867 }
71868
71869
71870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71871   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71872
71873   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71874   {
71875     try {
71876       (arg1)->DisableDomain();
71877     } catch (std::out_of_range& e) {
71878       {
71879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71880       };
71881     } catch (std::exception& e) {
71882       {
71883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71884       };
71885     } catch (...) {
71886       {
71887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71888       };
71889     }
71890   }
71891 }
71892
71893
71894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71895   float jresult ;
71896   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71897   float arg2 ;
71898   float arg3 ;
71899   float arg4 ;
71900   float result;
71901
71902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71903   arg2 = (float)jarg2;
71904   arg3 = (float)jarg3;
71905   arg4 = (float)jarg4;
71906   {
71907     try {
71908       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71909     } catch (std::out_of_range& e) {
71910       {
71911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71912       };
71913     } catch (std::exception& e) {
71914       {
71915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71920       };
71921     }
71922   }
71923   jresult = result;
71924   return jresult;
71925 }
71926
71927
71928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71929   float jresult ;
71930   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71931   float arg2 ;
71932   float arg3 ;
71933   float result;
71934
71935   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71936   arg2 = (float)jarg2;
71937   arg3 = (float)jarg3;
71938   {
71939     try {
71940       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71941     } catch (std::out_of_range& e) {
71942       {
71943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71944       };
71945     } catch (std::exception& e) {
71946       {
71947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71948       };
71949     } catch (...) {
71950       {
71951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71952       };
71953     }
71954   }
71955   jresult = result;
71956   return jresult;
71957 }
71958
71959
71960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71961   float jresult ;
71962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71963   float arg2 ;
71964   float result;
71965
71966   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71967   arg2 = (float)jarg2;
71968   {
71969     try {
71970       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71982       };
71983     }
71984   }
71985   jresult = result;
71986   return jresult;
71987 }
71988
71989
71990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71991   float jresult ;
71992   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71993   float arg2 ;
71994   float arg3 ;
71995   float arg4 ;
71996   Dali::Toolkit::ClampState *arg5 = 0 ;
71997   float result;
71998
71999   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72000   arg2 = (float)jarg2;
72001   arg3 = (float)jarg3;
72002   arg4 = (float)jarg4;
72003   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72004   if (!arg5) {
72005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72006     return 0;
72007   }
72008   {
72009     try {
72010       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72011     } catch (std::out_of_range& e) {
72012       {
72013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72014       };
72015     } catch (std::exception& e) {
72016       {
72017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72018       };
72019     } catch (...) {
72020       {
72021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72022       };
72023     }
72024   }
72025   jresult = result;
72026   return jresult;
72027 }
72028
72029
72030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72031   float jresult ;
72032   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72033   float arg2 ;
72034   float arg3 ;
72035   float arg4 ;
72036   float arg5 ;
72037   float result;
72038
72039   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72040   arg2 = (float)jarg2;
72041   arg3 = (float)jarg3;
72042   arg4 = (float)jarg4;
72043   arg5 = (float)jarg5;
72044   {
72045     try {
72046       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72047     } catch (std::out_of_range& e) {
72048       {
72049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72050       };
72051     } catch (std::exception& e) {
72052       {
72053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72054       };
72055     } catch (...) {
72056       {
72057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72058       };
72059     }
72060   }
72061   jresult = result;
72062   return jresult;
72063 }
72064
72065
72066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72067   float jresult ;
72068   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72069   float arg2 ;
72070   float arg3 ;
72071   float arg4 ;
72072   float result;
72073
72074   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72075   arg2 = (float)jarg2;
72076   arg3 = (float)jarg3;
72077   arg4 = (float)jarg4;
72078   {
72079     try {
72080       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72081     } catch (std::out_of_range& e) {
72082       {
72083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72084       };
72085     } catch (std::exception& e) {
72086       {
72087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72088       };
72089     } catch (...) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72092       };
72093     }
72094   }
72095   jresult = result;
72096   return jresult;
72097 }
72098
72099
72100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72101   float jresult ;
72102   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72103   float arg2 ;
72104   float arg3 ;
72105   float result;
72106
72107   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72108   arg2 = (float)jarg2;
72109   arg3 = (float)jarg3;
72110   {
72111     try {
72112       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72113     } catch (std::out_of_range& e) {
72114       {
72115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72116       };
72117     } catch (std::exception& e) {
72118       {
72119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72120       };
72121     } catch (...) {
72122       {
72123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72124       };
72125     }
72126   }
72127   jresult = result;
72128   return jresult;
72129 }
72130
72131
72132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72133   float jresult ;
72134   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72135   float arg2 ;
72136   float result;
72137
72138   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72139   arg2 = (float)jarg2;
72140   {
72141     try {
72142       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72143     } catch (std::out_of_range& e) {
72144       {
72145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72146       };
72147     } catch (std::exception& e) {
72148       {
72149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72150       };
72151     } catch (...) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72154       };
72155     }
72156   }
72157   jresult = result;
72158   return jresult;
72159 }
72160
72161
72162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72163   float jresult ;
72164   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72165   float arg2 ;
72166   float arg3 ;
72167   float arg4 ;
72168   float arg5 ;
72169   Dali::Toolkit::ClampState *arg6 = 0 ;
72170   float result;
72171
72172   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72173   arg2 = (float)jarg2;
72174   arg3 = (float)jarg3;
72175   arg4 = (float)jarg4;
72176   arg5 = (float)jarg5;
72177   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72178   if (!arg6) {
72179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72180     return 0;
72181   }
72182   {
72183     try {
72184       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72185     } catch (std::out_of_range& e) {
72186       {
72187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72188       };
72189     } catch (std::exception& e) {
72190       {
72191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72192       };
72193     } catch (...) {
72194       {
72195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72196       };
72197     }
72198   }
72199   jresult = result;
72200   return jresult;
72201 }
72202
72203
72204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72205   void * jresult ;
72206   Dali::Toolkit::DefaultRuler *result = 0 ;
72207
72208   {
72209     try {
72210       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72211     } catch (std::out_of_range& e) {
72212       {
72213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72214       };
72215     } catch (std::exception& e) {
72216       {
72217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72218       };
72219     } catch (...) {
72220       {
72221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72222       };
72223     }
72224   }
72225   jresult = (void *)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72231   float jresult ;
72232   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72233   float arg2 ;
72234   float arg3 ;
72235   float result;
72236
72237   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72238   arg2 = (float)jarg2;
72239   arg3 = (float)jarg3;
72240   {
72241     try {
72242       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72243     } catch (std::out_of_range& e) {
72244       {
72245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72246       };
72247     } catch (std::exception& e) {
72248       {
72249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72250       };
72251     } catch (...) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72254       };
72255     }
72256   }
72257   jresult = result;
72258   return jresult;
72259 }
72260
72261
72262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72263   float jresult ;
72264   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72265   unsigned int arg2 ;
72266   unsigned int *arg3 = 0 ;
72267   bool arg4 ;
72268   float result;
72269
72270   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72271   arg2 = (unsigned int)jarg2;
72272   arg3 = (unsigned int *)jarg3;
72273   arg4 = jarg4 ? true : false;
72274   {
72275     try {
72276       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72277     } catch (std::out_of_range& e) {
72278       {
72279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72280       };
72281     } catch (std::exception& e) {
72282       {
72283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72284       };
72285     } catch (...) {
72286       {
72287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72288       };
72289     }
72290   }
72291   jresult = result;
72292   return jresult;
72293 }
72294
72295
72296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72297   unsigned int jresult ;
72298   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72299   float arg2 ;
72300   bool arg3 ;
72301   unsigned int result;
72302
72303   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72304   arg2 = (float)jarg2;
72305   arg3 = jarg3 ? true : false;
72306   {
72307     try {
72308       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72309     } catch (std::out_of_range& e) {
72310       {
72311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72312       };
72313     } catch (std::exception& e) {
72314       {
72315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72316       };
72317     } catch (...) {
72318       {
72319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72320       };
72321     }
72322   }
72323   jresult = result;
72324   return jresult;
72325 }
72326
72327
72328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72329   unsigned int jresult ;
72330   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72331   unsigned int result;
72332
72333   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72334   {
72335     try {
72336       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72337     } catch (std::out_of_range& e) {
72338       {
72339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72340       };
72341     } catch (std::exception& e) {
72342       {
72343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72344       };
72345     } catch (...) {
72346       {
72347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72348       };
72349     }
72350   }
72351   jresult = result;
72352   return jresult;
72353 }
72354
72355
72356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72357   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72358
72359   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72360   {
72361     try {
72362       delete arg1;
72363     } catch (std::out_of_range& e) {
72364       {
72365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72366       };
72367     } catch (std::exception& e) {
72368       {
72369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72374       };
72375     }
72376   }
72377 }
72378
72379
72380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72381   void * jresult ;
72382   float arg1 ;
72383   Dali::Toolkit::FixedRuler *result = 0 ;
72384
72385   arg1 = (float)jarg1;
72386   {
72387     try {
72388       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (...) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72400       };
72401     }
72402   }
72403   jresult = (void *)result;
72404   return jresult;
72405 }
72406
72407
72408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72409   void * jresult ;
72410   Dali::Toolkit::FixedRuler *result = 0 ;
72411
72412   {
72413     try {
72414       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72415     } catch (std::out_of_range& e) {
72416       {
72417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72418       };
72419     } catch (std::exception& e) {
72420       {
72421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72422       };
72423     } catch (...) {
72424       {
72425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72426       };
72427     }
72428   }
72429   jresult = (void *)result;
72430   return jresult;
72431 }
72432
72433
72434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72435   float jresult ;
72436   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72437   float arg2 ;
72438   float arg3 ;
72439   float result;
72440
72441   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72442   arg2 = (float)jarg2;
72443   arg3 = (float)jarg3;
72444   {
72445     try {
72446       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72447     } catch (std::out_of_range& e) {
72448       {
72449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72450       };
72451     } catch (std::exception& e) {
72452       {
72453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72454       };
72455     } catch (...) {
72456       {
72457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72458       };
72459     }
72460   }
72461   jresult = result;
72462   return jresult;
72463 }
72464
72465
72466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72467   float jresult ;
72468   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72469   unsigned int arg2 ;
72470   unsigned int *arg3 = 0 ;
72471   bool arg4 ;
72472   float result;
72473
72474   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72475   arg2 = (unsigned int)jarg2;
72476   arg3 = (unsigned int *)jarg3;
72477   arg4 = jarg4 ? true : false;
72478   {
72479     try {
72480       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72481     } catch (std::out_of_range& e) {
72482       {
72483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (std::exception& e) {
72486       {
72487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72488       };
72489     } catch (...) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72492       };
72493     }
72494   }
72495   jresult = result;
72496   return jresult;
72497 }
72498
72499
72500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72501   unsigned int jresult ;
72502   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72503   float arg2 ;
72504   bool arg3 ;
72505   unsigned int result;
72506
72507   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72508   arg2 = (float)jarg2;
72509   arg3 = jarg3 ? true : false;
72510   {
72511     try {
72512       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72513     } catch (std::out_of_range& e) {
72514       {
72515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72516       };
72517     } catch (std::exception& e) {
72518       {
72519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72520       };
72521     } catch (...) {
72522       {
72523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72524       };
72525     }
72526   }
72527   jresult = result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72533   unsigned int jresult ;
72534   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72535   unsigned int result;
72536
72537   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72538   {
72539     try {
72540       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72541     } catch (std::out_of_range& e) {
72542       {
72543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (std::exception& e) {
72546       {
72547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72548       };
72549     } catch (...) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72552       };
72553     }
72554   }
72555   jresult = result;
72556   return jresult;
72557 }
72558
72559
72560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72561   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72562
72563   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72564   {
72565     try {
72566       delete arg1;
72567     } catch (std::out_of_range& e) {
72568       {
72569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72570       };
72571     } catch (std::exception& e) {
72572       {
72573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72574       };
72575     } catch (...) {
72576       {
72577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72578       };
72579     }
72580   }
72581 }
72582
72583
72584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72585   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72586   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72587
72588   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72589   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72590   if (arg1) (arg1)->scale = *arg2;
72591 }
72592
72593
72594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72595   void * jresult ;
72596   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72597   Dali::Toolkit::ClampState2D *result = 0 ;
72598
72599   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72600   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72601   jresult = (void *)result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72607   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72608   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72609
72610   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72611   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72612   if (arg1) (arg1)->position = *arg2;
72613 }
72614
72615
72616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72617   void * jresult ;
72618   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72619   Dali::Toolkit::ClampState2D *result = 0 ;
72620
72621   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72622   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72623   jresult = (void *)result;
72624   return jresult;
72625 }
72626
72627
72628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72629   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72630   Dali::Toolkit::ClampState arg2 ;
72631
72632   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72633   arg2 = (Dali::Toolkit::ClampState)jarg2;
72634   if (arg1) (arg1)->rotation = arg2;
72635 }
72636
72637
72638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72639   int jresult ;
72640   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72641   Dali::Toolkit::ClampState result;
72642
72643   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72644   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72645   jresult = (int)result;
72646   return jresult;
72647 }
72648
72649
72650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72651   void * jresult ;
72652   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72653
72654   {
72655     try {
72656       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72657     } catch (std::out_of_range& e) {
72658       {
72659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (std::exception& e) {
72662       {
72663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72664       };
72665     } catch (...) {
72666       {
72667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72668       };
72669     }
72670   }
72671   jresult = (void *)result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72677   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72678
72679   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72680   {
72681     try {
72682       delete arg1;
72683     } catch (std::out_of_range& e) {
72684       {
72685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72686       };
72687     } catch (std::exception& e) {
72688       {
72689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72690       };
72691     } catch (...) {
72692       {
72693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72694       };
72695     }
72696   }
72697 }
72698
72699
72700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72701   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72702   Dali::Toolkit::SnapType arg2 ;
72703
72704   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72705   arg2 = (Dali::Toolkit::SnapType)jarg2;
72706   if (arg1) (arg1)->type = arg2;
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72711   int jresult ;
72712   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72713   Dali::Toolkit::SnapType result;
72714
72715   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72716   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72717   jresult = (int)result;
72718   return jresult;
72719 }
72720
72721
72722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72723   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72724   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72725
72726   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72727   arg2 = (Dali::Vector2 *)jarg2;
72728   if (arg1) (arg1)->position = *arg2;
72729 }
72730
72731
72732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72733   void * jresult ;
72734   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72735   Dali::Vector2 *result = 0 ;
72736
72737   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72738   result = (Dali::Vector2 *)& ((arg1)->position);
72739   jresult = (void *)result;
72740   return jresult;
72741 }
72742
72743
72744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72745   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72746   float arg2 ;
72747
72748   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72749   arg2 = (float)jarg2;
72750   if (arg1) (arg1)->duration = arg2;
72751 }
72752
72753
72754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72755   float jresult ;
72756   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72757   float result;
72758
72759   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72760   result = (float) ((arg1)->duration);
72761   jresult = result;
72762   return jresult;
72763 }
72764
72765
72766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72767   void * jresult ;
72768   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72769
72770   {
72771     try {
72772       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72773     } catch (std::out_of_range& e) {
72774       {
72775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72776       };
72777     } catch (std::exception& e) {
72778       {
72779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72780       };
72781     } catch (...) {
72782       {
72783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72784       };
72785     }
72786   }
72787   jresult = (void *)result;
72788   return jresult;
72789 }
72790
72791
72792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72793   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72794
72795   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72796   {
72797     try {
72798       delete arg1;
72799     } catch (std::out_of_range& e) {
72800       {
72801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72802       };
72803     } catch (std::exception& e) {
72804       {
72805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72806       };
72807     } catch (...) {
72808       {
72809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72810       };
72811     }
72812   }
72813 }
72814
72815
72816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72817   int jresult ;
72818   int result;
72819
72820   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72821   jresult = (int)result;
72822   return jresult;
72823 }
72824
72825
72826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72827   int jresult ;
72828   int result;
72829
72830   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72831   jresult = (int)result;
72832   return jresult;
72833 }
72834
72835
72836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72837   int jresult ;
72838   int result;
72839
72840   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72841   jresult = (int)result;
72842   return jresult;
72843 }
72844
72845
72846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72847   int jresult ;
72848   int result;
72849
72850   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72851   jresult = (int)result;
72852   return jresult;
72853 }
72854
72855
72856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72857   int jresult ;
72858   int result;
72859
72860   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72861   jresult = (int)result;
72862   return jresult;
72863 }
72864
72865
72866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72867   int jresult ;
72868   int result;
72869
72870   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72871   jresult = (int)result;
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72877   int jresult ;
72878   int result;
72879
72880   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72881   jresult = (int)result;
72882   return jresult;
72883 }
72884
72885
72886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72887   int jresult ;
72888   int result;
72889
72890   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72891   jresult = (int)result;
72892   return jresult;
72893 }
72894
72895
72896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72897   int jresult ;
72898   int result;
72899
72900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72901   jresult = (int)result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72907   int jresult ;
72908   int result;
72909
72910   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72911   jresult = (int)result;
72912   return jresult;
72913 }
72914
72915
72916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72917   int jresult ;
72918   int result;
72919
72920   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72921   jresult = (int)result;
72922   return jresult;
72923 }
72924
72925
72926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72927   int jresult ;
72928   int result;
72929
72930   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72931   jresult = (int)result;
72932   return jresult;
72933 }
72934
72935
72936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72937   int jresult ;
72938   int result;
72939
72940   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72941   jresult = (int)result;
72942   return jresult;
72943 }
72944
72945
72946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72947   int jresult ;
72948   int result;
72949
72950   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72951   jresult = (int)result;
72952   return jresult;
72953 }
72954
72955
72956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72957   int jresult ;
72958   int result;
72959
72960   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72961   jresult = (int)result;
72962   return jresult;
72963 }
72964
72965
72966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72967   int jresult ;
72968   int result;
72969
72970   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72971   jresult = (int)result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72977   int jresult ;
72978   int result;
72979
72980   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72981   jresult = (int)result;
72982   return jresult;
72983 }
72984
72985
72986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72987   int jresult ;
72988   int result;
72989
72990   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
72991   jresult = (int)result;
72992   return jresult;
72993 }
72994
72995
72996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
72997   int jresult ;
72998   int result;
72999
73000   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73001   jresult = (int)result;
73002   return jresult;
73003 }
73004
73005
73006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73007   int jresult ;
73008   int result;
73009
73010   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73011   jresult = (int)result;
73012   return jresult;
73013 }
73014
73015
73016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73017   int jresult ;
73018   int result;
73019
73020   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73021   jresult = (int)result;
73022   return jresult;
73023 }
73024
73025
73026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73027   int jresult ;
73028   int result;
73029
73030   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73031   jresult = (int)result;
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73037   int jresult ;
73038   int result;
73039
73040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73041   jresult = (int)result;
73042   return jresult;
73043 }
73044
73045
73046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73047   int jresult ;
73048   int result;
73049
73050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73051   jresult = (int)result;
73052   return jresult;
73053 }
73054
73055
73056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73057   int jresult ;
73058   int result;
73059
73060   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73061   jresult = (int)result;
73062   return jresult;
73063 }
73064
73065
73066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73067   void * jresult ;
73068   Dali::Toolkit::ScrollView::Property *result = 0 ;
73069
73070   {
73071     try {
73072       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73073     } catch (std::out_of_range& e) {
73074       {
73075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73076       };
73077     } catch (std::exception& e) {
73078       {
73079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73080       };
73081     } catch (...) {
73082       {
73083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73084       };
73085     }
73086   }
73087   jresult = (void *)result;
73088   return jresult;
73089 }
73090
73091
73092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73093   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73094
73095   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73096   {
73097     try {
73098       delete arg1;
73099     } catch (std::out_of_range& e) {
73100       {
73101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73102       };
73103     } catch (std::exception& e) {
73104       {
73105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73106       };
73107     } catch (...) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73110       };
73111     }
73112   }
73113 }
73114
73115
73116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73117   void * jresult ;
73118   Dali::Toolkit::ScrollView *result = 0 ;
73119
73120   {
73121     try {
73122       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73123     } catch (std::out_of_range& e) {
73124       {
73125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (std::exception& e) {
73128       {
73129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (...) {
73132       {
73133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73134       };
73135     }
73136   }
73137   jresult = (void *)result;
73138   return jresult;
73139 }
73140
73141
73142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73143   void * jresult ;
73144   Dali::Toolkit::ScrollView *arg1 = 0 ;
73145   Dali::Toolkit::ScrollView *result = 0 ;
73146
73147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73148   if (!arg1) {
73149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73150     return 0;
73151   }
73152   {
73153     try {
73154       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73155     } catch (std::out_of_range& e) {
73156       {
73157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73158       };
73159     } catch (std::exception& e) {
73160       {
73161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (...) {
73164       {
73165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73166       };
73167     }
73168   }
73169   jresult = (void *)result;
73170   return jresult;
73171 }
73172
73173
73174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73175   void * jresult ;
73176   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73177   Dali::Toolkit::ScrollView *arg2 = 0 ;
73178   Dali::Toolkit::ScrollView *result = 0 ;
73179
73180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73181   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73182   if (!arg2) {
73183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73184     return 0;
73185   }
73186   {
73187     try {
73188       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73189     } catch (std::out_of_range& e) {
73190       {
73191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (std::exception& e) {
73194       {
73195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73196       };
73197     } catch (...) {
73198       {
73199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73200       };
73201     }
73202   }
73203   jresult = (void *)result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73210
73211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73212   {
73213     try {
73214       delete arg1;
73215     } catch (std::out_of_range& e) {
73216       {
73217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73218       };
73219     } catch (std::exception& e) {
73220       {
73221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73222       };
73223     } catch (...) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73226       };
73227     }
73228   }
73229 }
73230
73231
73232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73233   void * jresult ;
73234   Dali::Toolkit::ScrollView result;
73235
73236   {
73237     try {
73238       result = Dali::Toolkit::ScrollView::New();
73239     } catch (std::out_of_range& e) {
73240       {
73241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73242       };
73243     } catch (std::exception& e) {
73244       {
73245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73246       };
73247     } catch (...) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73250       };
73251     }
73252   }
73253   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73254   return jresult;
73255 }
73256
73257
73258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73259   void * jresult ;
73260   Dali::BaseHandle arg1 ;
73261   Dali::BaseHandle *argp1 ;
73262   Dali::Toolkit::ScrollView result;
73263
73264   argp1 = (Dali::BaseHandle *)jarg1;
73265   if (!argp1) {
73266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73267     return 0;
73268   }
73269   arg1 = *argp1;
73270   {
73271     try {
73272       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73273     } catch (std::out_of_range& e) {
73274       {
73275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73276       };
73277     } catch (std::exception& e) {
73278       {
73279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73280       };
73281     } catch (...) {
73282       {
73283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73284       };
73285     }
73286   }
73287   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73288   return jresult;
73289 }
73290
73291
73292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73293   void * jresult ;
73294   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73295   Dali::AlphaFunction result;
73296
73297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73298   {
73299     try {
73300       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73301     } catch (std::out_of_range& e) {
73302       {
73303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73304       };
73305     } catch (std::exception& e) {
73306       {
73307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73308       };
73309     } catch (...) {
73310       {
73311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73312       };
73313     }
73314   }
73315   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73316   return jresult;
73317 }
73318
73319
73320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73322   Dali::AlphaFunction arg2 ;
73323   Dali::AlphaFunction *argp2 ;
73324
73325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73326   argp2 = (Dali::AlphaFunction *)jarg2;
73327   if (!argp2) {
73328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73329     return ;
73330   }
73331   arg2 = *argp2;
73332   {
73333     try {
73334       (arg1)->SetScrollSnapAlphaFunction(arg2);
73335     } catch (std::out_of_range& e) {
73336       {
73337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73338       };
73339     } catch (std::exception& e) {
73340       {
73341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73342       };
73343     } catch (...) {
73344       {
73345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73346       };
73347     }
73348   }
73349 }
73350
73351
73352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73353   void * jresult ;
73354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73355   Dali::AlphaFunction result;
73356
73357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73358   {
73359     try {
73360       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73361     } catch (std::out_of_range& e) {
73362       {
73363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73364       };
73365     } catch (std::exception& e) {
73366       {
73367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73368       };
73369     } catch (...) {
73370       {
73371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73372       };
73373     }
73374   }
73375   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73376   return jresult;
73377 }
73378
73379
73380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73381   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73382   Dali::AlphaFunction arg2 ;
73383   Dali::AlphaFunction *argp2 ;
73384
73385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73386   argp2 = (Dali::AlphaFunction *)jarg2;
73387   if (!argp2) {
73388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73389     return ;
73390   }
73391   arg2 = *argp2;
73392   {
73393     try {
73394       (arg1)->SetScrollFlickAlphaFunction(arg2);
73395     } catch (std::out_of_range& e) {
73396       {
73397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73398       };
73399     } catch (std::exception& e) {
73400       {
73401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73402       };
73403     } catch (...) {
73404       {
73405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73406       };
73407     }
73408   }
73409 }
73410
73411
73412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73413   float jresult ;
73414   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73415   float result;
73416
73417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73418   {
73419     try {
73420       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73421     } catch (std::out_of_range& e) {
73422       {
73423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73424       };
73425     } catch (std::exception& e) {
73426       {
73427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (...) {
73430       {
73431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73432       };
73433     }
73434   }
73435   jresult = result;
73436   return jresult;
73437 }
73438
73439
73440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73442   float arg2 ;
73443
73444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73445   arg2 = (float)jarg2;
73446   {
73447     try {
73448       (arg1)->SetScrollSnapDuration(arg2);
73449     } catch (std::out_of_range& e) {
73450       {
73451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73452       };
73453     } catch (std::exception& e) {
73454       {
73455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73456       };
73457     } catch (...) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73460       };
73461     }
73462   }
73463 }
73464
73465
73466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73467   float jresult ;
73468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73469   float result;
73470
73471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73472   {
73473     try {
73474       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73475     } catch (std::out_of_range& e) {
73476       {
73477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73478       };
73479     } catch (std::exception& e) {
73480       {
73481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73482       };
73483     } catch (...) {
73484       {
73485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73486       };
73487     }
73488   }
73489   jresult = result;
73490   return jresult;
73491 }
73492
73493
73494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73496   float arg2 ;
73497
73498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73499   arg2 = (float)jarg2;
73500   {
73501     try {
73502       (arg1)->SetScrollFlickDuration(arg2);
73503     } catch (std::out_of_range& e) {
73504       {
73505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73506       };
73507     } catch (std::exception& e) {
73508       {
73509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73510       };
73511     } catch (...) {
73512       {
73513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73514       };
73515     }
73516   }
73517 }
73518
73519
73520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73522   Dali::Toolkit::RulerPtr arg2 ;
73523   Dali::Toolkit::RulerPtr *argp2 ;
73524
73525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73526   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73527   if (!argp2) {
73528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73529     return ;
73530   }
73531   arg2 = *argp2;
73532   {
73533     try {
73534       (arg1)->SetRulerX(arg2);
73535     } catch (std::out_of_range& e) {
73536       {
73537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (std::exception& e) {
73540       {
73541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (...) {
73544       {
73545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73546       };
73547     }
73548   }
73549 }
73550
73551
73552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73553   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73554   Dali::Toolkit::RulerPtr arg2 ;
73555   Dali::Toolkit::RulerPtr *argp2 ;
73556
73557   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73558   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73559   if (!argp2) {
73560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73561     return ;
73562   }
73563   arg2 = *argp2;
73564   {
73565     try {
73566       (arg1)->SetRulerY(arg2);
73567     } catch (std::out_of_range& e) {
73568       {
73569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73570       };
73571     } catch (std::exception& e) {
73572       {
73573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73578       };
73579     }
73580   }
73581 }
73582
73583
73584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73585   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73586   bool arg2 ;
73587
73588   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73589   arg2 = jarg2 ? true : false;
73590   {
73591     try {
73592       (arg1)->SetScrollSensitive(arg2);
73593     } catch (std::out_of_range& e) {
73594       {
73595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73596       };
73597     } catch (std::exception& e) {
73598       {
73599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73600       };
73601     } catch (...) {
73602       {
73603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73604       };
73605     }
73606   }
73607 }
73608
73609
73610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73611   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73612   float arg2 ;
73613   float arg3 ;
73614
73615   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73616   arg2 = (float)jarg2;
73617   arg3 = (float)jarg3;
73618   {
73619     try {
73620       (arg1)->SetMaxOvershoot(arg2,arg3);
73621     } catch (std::out_of_range& e) {
73622       {
73623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73624       };
73625     } catch (std::exception& e) {
73626       {
73627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73628       };
73629     } catch (...) {
73630       {
73631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73632       };
73633     }
73634   }
73635 }
73636
73637
73638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73640   Dali::AlphaFunction arg2 ;
73641   Dali::AlphaFunction *argp2 ;
73642
73643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73644   argp2 = (Dali::AlphaFunction *)jarg2;
73645   if (!argp2) {
73646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73647     return ;
73648   }
73649   arg2 = *argp2;
73650   {
73651     try {
73652       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73653     } catch (std::out_of_range& e) {
73654       {
73655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73656       };
73657     } catch (std::exception& e) {
73658       {
73659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73660       };
73661     } catch (...) {
73662       {
73663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73664       };
73665     }
73666   }
73667 }
73668
73669
73670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73672   float arg2 ;
73673
73674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73675   arg2 = (float)jarg2;
73676   {
73677     try {
73678       (arg1)->SetSnapOvershootDuration(arg2);
73679     } catch (std::out_of_range& e) {
73680       {
73681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73682       };
73683     } catch (std::exception& e) {
73684       {
73685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73686       };
73687     } catch (...) {
73688       {
73689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73690       };
73691     }
73692   }
73693 }
73694
73695
73696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73697   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73698   bool arg2 ;
73699
73700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73701   arg2 = jarg2 ? true : false;
73702   {
73703     try {
73704       (arg1)->SetActorAutoSnap(arg2);
73705     } catch (std::out_of_range& e) {
73706       {
73707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73708       };
73709     } catch (std::exception& e) {
73710       {
73711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73712       };
73713     } catch (...) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73716       };
73717     }
73718   }
73719 }
73720
73721
73722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73723   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73724   bool arg2 ;
73725
73726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73727   arg2 = jarg2 ? true : false;
73728   {
73729     try {
73730       (arg1)->SetWrapMode(arg2);
73731     } catch (std::out_of_range& e) {
73732       {
73733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73734       };
73735     } catch (std::exception& e) {
73736       {
73737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73738       };
73739     } catch (...) {
73740       {
73741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73742       };
73743     }
73744   }
73745 }
73746
73747
73748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73749   int jresult ;
73750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73751   int result;
73752
73753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73754   {
73755     try {
73756       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73757     } catch (std::out_of_range& e) {
73758       {
73759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73760       };
73761     } catch (std::exception& e) {
73762       {
73763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73764       };
73765     } catch (...) {
73766       {
73767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73768       };
73769     }
73770   }
73771   jresult = result;
73772   return jresult;
73773 }
73774
73775
73776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73778   int arg2 ;
73779
73780   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73781   arg2 = (int)jarg2;
73782   {
73783     try {
73784       (arg1)->SetScrollUpdateDistance(arg2);
73785     } catch (std::out_of_range& e) {
73786       {
73787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73788       };
73789     } catch (std::exception& e) {
73790       {
73791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73792       };
73793     } catch (...) {
73794       {
73795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73796       };
73797     }
73798   }
73799 }
73800
73801
73802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73803   unsigned int jresult ;
73804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73805   bool result;
73806
73807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73808   {
73809     try {
73810       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73811     } catch (std::out_of_range& e) {
73812       {
73813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73814       };
73815     } catch (std::exception& e) {
73816       {
73817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73818       };
73819     } catch (...) {
73820       {
73821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73822       };
73823     }
73824   }
73825   jresult = result;
73826   return jresult;
73827 }
73828
73829
73830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73832   bool arg2 ;
73833
73834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73835   arg2 = jarg2 ? true : false;
73836   {
73837     try {
73838       (arg1)->SetAxisAutoLock(arg2);
73839     } catch (std::out_of_range& e) {
73840       {
73841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73842       };
73843     } catch (std::exception& e) {
73844       {
73845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73846       };
73847     } catch (...) {
73848       {
73849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73850       };
73851     }
73852   }
73853 }
73854
73855
73856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73857   float jresult ;
73858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73859   float result;
73860
73861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73862   {
73863     try {
73864       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73865     } catch (std::out_of_range& e) {
73866       {
73867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73868       };
73869     } catch (std::exception& e) {
73870       {
73871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73872       };
73873     } catch (...) {
73874       {
73875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73876       };
73877     }
73878   }
73879   jresult = result;
73880   return jresult;
73881 }
73882
73883
73884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73886   float arg2 ;
73887
73888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73889   arg2 = (float)jarg2;
73890   {
73891     try {
73892       (arg1)->SetAxisAutoLockGradient(arg2);
73893     } catch (std::out_of_range& e) {
73894       {
73895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73896       };
73897     } catch (std::exception& e) {
73898       {
73899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73900       };
73901     } catch (...) {
73902       {
73903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73904       };
73905     }
73906   }
73907 }
73908
73909
73910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73911   float jresult ;
73912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73913   float result;
73914
73915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73916   {
73917     try {
73918       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73919     } catch (std::out_of_range& e) {
73920       {
73921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (std::exception& e) {
73924       {
73925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73926       };
73927     } catch (...) {
73928       {
73929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73930       };
73931     }
73932   }
73933   jresult = result;
73934   return jresult;
73935 }
73936
73937
73938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73940   float arg2 ;
73941
73942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73943   arg2 = (float)jarg2;
73944   {
73945     try {
73946       (arg1)->SetFrictionCoefficient(arg2);
73947     } catch (std::out_of_range& e) {
73948       {
73949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73950       };
73951     } catch (std::exception& e) {
73952       {
73953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73954       };
73955     } catch (...) {
73956       {
73957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73958       };
73959     }
73960   }
73961 }
73962
73963
73964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73965   float jresult ;
73966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73967   float result;
73968
73969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73970   {
73971     try {
73972       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73980       };
73981     } catch (...) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73984       };
73985     }
73986   }
73987   jresult = result;
73988   return jresult;
73989 }
73990
73991
73992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
73993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73994   float arg2 ;
73995
73996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73997   arg2 = (float)jarg2;
73998   {
73999     try {
74000       (arg1)->SetFlickSpeedCoefficient(arg2);
74001     } catch (std::out_of_range& e) {
74002       {
74003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74004       };
74005     } catch (std::exception& e) {
74006       {
74007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74008       };
74009     } catch (...) {
74010       {
74011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74012       };
74013     }
74014   }
74015 }
74016
74017
74018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74019   void * jresult ;
74020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74021   Dali::Vector2 result;
74022
74023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74024   {
74025     try {
74026       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74027     } catch (std::out_of_range& e) {
74028       {
74029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (std::exception& e) {
74032       {
74033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74034       };
74035     } catch (...) {
74036       {
74037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74038       };
74039     }
74040   }
74041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74042   return jresult;
74043 }
74044
74045
74046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74048   Dali::Vector2 *arg2 = 0 ;
74049
74050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74051   arg2 = (Dali::Vector2 *)jarg2;
74052   if (!arg2) {
74053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74054     return ;
74055   }
74056   {
74057     try {
74058       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74059     } catch (std::out_of_range& e) {
74060       {
74061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74062       };
74063     } catch (std::exception& e) {
74064       {
74065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74066       };
74067     } catch (...) {
74068       {
74069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74070       };
74071     }
74072   }
74073 }
74074
74075
74076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74077   float jresult ;
74078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74079   float result;
74080
74081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74082   {
74083     try {
74084       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74085     } catch (std::out_of_range& e) {
74086       {
74087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74088       };
74089     } catch (std::exception& e) {
74090       {
74091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74092       };
74093     } catch (...) {
74094       {
74095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74096       };
74097     }
74098   }
74099   jresult = result;
74100   return jresult;
74101 }
74102
74103
74104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74106   float arg2 ;
74107
74108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74109   arg2 = (float)jarg2;
74110   {
74111     try {
74112       (arg1)->SetMinimumSpeedForFlick(arg2);
74113     } catch (std::out_of_range& e) {
74114       {
74115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74116       };
74117     } catch (std::exception& e) {
74118       {
74119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74120       };
74121     } catch (...) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74124       };
74125     }
74126   }
74127 }
74128
74129
74130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74131   float jresult ;
74132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74133   float result;
74134
74135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74136   {
74137     try {
74138       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74150       };
74151     }
74152   }
74153   jresult = result;
74154   return jresult;
74155 }
74156
74157
74158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74159   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74160   float arg2 ;
74161
74162   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74163   arg2 = (float)jarg2;
74164   {
74165     try {
74166       (arg1)->SetMaxFlickSpeed(arg2);
74167     } catch (std::out_of_range& e) {
74168       {
74169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74170       };
74171     } catch (std::exception& e) {
74172       {
74173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74174       };
74175     } catch (...) {
74176       {
74177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74178       };
74179     }
74180   }
74181 }
74182
74183
74184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74185   void * jresult ;
74186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74187   Dali::Vector2 result;
74188
74189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74190   {
74191     try {
74192       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74193     } catch (std::out_of_range& e) {
74194       {
74195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (std::exception& e) {
74198       {
74199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74200       };
74201     } catch (...) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74204       };
74205     }
74206   }
74207   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74214   Dali::Vector2 arg2 ;
74215   Dali::Vector2 *argp2 ;
74216
74217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74218   argp2 = (Dali::Vector2 *)jarg2;
74219   if (!argp2) {
74220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74221     return ;
74222   }
74223   arg2 = *argp2;
74224   {
74225     try {
74226       (arg1)->SetWheelScrollDistanceStep(arg2);
74227     } catch (std::out_of_range& e) {
74228       {
74229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74230       };
74231     } catch (std::exception& e) {
74232       {
74233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74234       };
74235     } catch (...) {
74236       {
74237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74238       };
74239     }
74240   }
74241 }
74242
74243
74244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74245   void * jresult ;
74246   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74247   Dali::Vector2 result;
74248
74249   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74250   {
74251     try {
74252       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74253     } catch (std::out_of_range& e) {
74254       {
74255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74256       };
74257     } catch (std::exception& e) {
74258       {
74259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74260       };
74261     } catch (...) {
74262       {
74263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74264       };
74265     }
74266   }
74267   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74268   return jresult;
74269 }
74270
74271
74272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74273   unsigned int jresult ;
74274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74275   unsigned int result;
74276
74277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74278   {
74279     try {
74280       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74281     } catch (std::out_of_range& e) {
74282       {
74283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74284       };
74285     } catch (std::exception& e) {
74286       {
74287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74288       };
74289     } catch (...) {
74290       {
74291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74292       };
74293     }
74294   }
74295   jresult = result;
74296   return jresult;
74297 }
74298
74299
74300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74302   Dali::Vector2 *arg2 = 0 ;
74303
74304   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74305   arg2 = (Dali::Vector2 *)jarg2;
74306   if (!arg2) {
74307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74308     return ;
74309   }
74310   {
74311     try {
74312       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74313     } catch (std::out_of_range& e) {
74314       {
74315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74316       };
74317     } catch (std::exception& e) {
74318       {
74319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74320       };
74321     } catch (...) {
74322       {
74323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74324       };
74325     }
74326   }
74327 }
74328
74329
74330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74331   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74332   Dali::Vector2 *arg2 = 0 ;
74333   float arg3 ;
74334
74335   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74336   arg2 = (Dali::Vector2 *)jarg2;
74337   if (!arg2) {
74338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74339     return ;
74340   }
74341   arg3 = (float)jarg3;
74342   {
74343     try {
74344       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74345     } catch (std::out_of_range& e) {
74346       {
74347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74348       };
74349     } catch (std::exception& e) {
74350       {
74351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74356       };
74357     }
74358   }
74359 }
74360
74361
74362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74363   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74364   Dali::Vector2 *arg2 = 0 ;
74365   float arg3 ;
74366   Dali::AlphaFunction arg4 ;
74367   Dali::AlphaFunction *argp4 ;
74368
74369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74370   arg2 = (Dali::Vector2 *)jarg2;
74371   if (!arg2) {
74372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74373     return ;
74374   }
74375   arg3 = (float)jarg3;
74376   argp4 = (Dali::AlphaFunction *)jarg4;
74377   if (!argp4) {
74378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74379     return ;
74380   }
74381   arg4 = *argp4;
74382   {
74383     try {
74384       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74385     } catch (std::out_of_range& e) {
74386       {
74387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (std::exception& e) {
74390       {
74391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74396       };
74397     }
74398   }
74399 }
74400
74401
74402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74404   Dali::Vector2 *arg2 = 0 ;
74405   float arg3 ;
74406   Dali::Toolkit::DirectionBias arg4 ;
74407   Dali::Toolkit::DirectionBias arg5 ;
74408
74409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74410   arg2 = (Dali::Vector2 *)jarg2;
74411   if (!arg2) {
74412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74413     return ;
74414   }
74415   arg3 = (float)jarg3;
74416   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74417   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74418   {
74419     try {
74420       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74432       };
74433     }
74434   }
74435 }
74436
74437
74438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74440   Dali::Vector2 *arg2 = 0 ;
74441   float arg3 ;
74442   Dali::AlphaFunction arg4 ;
74443   Dali::Toolkit::DirectionBias arg5 ;
74444   Dali::Toolkit::DirectionBias arg6 ;
74445   Dali::AlphaFunction *argp4 ;
74446
74447   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74448   arg2 = (Dali::Vector2 *)jarg2;
74449   if (!arg2) {
74450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74451     return ;
74452   }
74453   arg3 = (float)jarg3;
74454   argp4 = (Dali::AlphaFunction *)jarg4;
74455   if (!argp4) {
74456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74457     return ;
74458   }
74459   arg4 = *argp4;
74460   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74461   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74462   {
74463     try {
74464       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74465     } catch (std::out_of_range& e) {
74466       {
74467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74468       };
74469     } catch (std::exception& e) {
74470       {
74471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74472       };
74473     } catch (...) {
74474       {
74475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74476       };
74477     }
74478   }
74479 }
74480
74481
74482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74484   unsigned int arg2 ;
74485
74486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74487   arg2 = (unsigned int)jarg2;
74488   {
74489     try {
74490       (arg1)->ScrollTo(arg2);
74491     } catch (std::out_of_range& e) {
74492       {
74493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74494       };
74495     } catch (std::exception& e) {
74496       {
74497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74498       };
74499     } catch (...) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74502       };
74503     }
74504   }
74505 }
74506
74507
74508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74510   unsigned int arg2 ;
74511   float arg3 ;
74512
74513   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74514   arg2 = (unsigned int)jarg2;
74515   arg3 = (float)jarg3;
74516   {
74517     try {
74518       (arg1)->ScrollTo(arg2,arg3);
74519     } catch (std::out_of_range& e) {
74520       {
74521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74522       };
74523     } catch (std::exception& e) {
74524       {
74525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74530       };
74531     }
74532   }
74533 }
74534
74535
74536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74538   unsigned int arg2 ;
74539   float arg3 ;
74540   Dali::Toolkit::DirectionBias arg4 ;
74541
74542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74543   arg2 = (unsigned int)jarg2;
74544   arg3 = (float)jarg3;
74545   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74546   {
74547     try {
74548       (arg1)->ScrollTo(arg2,arg3,arg4);
74549     } catch (std::out_of_range& e) {
74550       {
74551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74552       };
74553     } catch (std::exception& e) {
74554       {
74555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74556       };
74557     } catch (...) {
74558       {
74559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74560       };
74561     }
74562   }
74563 }
74564
74565
74566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74568   Dali::Actor *arg2 = 0 ;
74569
74570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74571   arg2 = (Dali::Actor *)jarg2;
74572   if (!arg2) {
74573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74574     return ;
74575   }
74576   {
74577     try {
74578       (arg1)->ScrollTo(*arg2);
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74586       };
74587     } catch (...) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74590       };
74591     }
74592   }
74593 }
74594
74595
74596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74597   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74598   Dali::Actor *arg2 = 0 ;
74599   float arg3 ;
74600
74601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74602   arg2 = (Dali::Actor *)jarg2;
74603   if (!arg2) {
74604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74605     return ;
74606   }
74607   arg3 = (float)jarg3;
74608   {
74609     try {
74610       (arg1)->ScrollTo(*arg2,arg3);
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74618       };
74619     } catch (...) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74622       };
74623     }
74624   }
74625 }
74626
74627
74628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74629   unsigned int jresult ;
74630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74631   bool result;
74632
74633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74634   {
74635     try {
74636       result = (bool)(arg1)->ScrollToSnapPoint();
74637     } catch (std::out_of_range& e) {
74638       {
74639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74640       };
74641     } catch (std::exception& e) {
74642       {
74643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74644       };
74645     } catch (...) {
74646       {
74647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74648       };
74649     }
74650   }
74651   jresult = result;
74652   return jresult;
74653 }
74654
74655
74656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74658   Dali::Constraint arg2 ;
74659   Dali::Constraint *argp2 ;
74660
74661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74662   argp2 = (Dali::Constraint *)jarg2;
74663   if (!argp2) {
74664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74665     return ;
74666   }
74667   arg2 = *argp2;
74668   {
74669     try {
74670       (arg1)->ApplyConstraintToChildren(arg2);
74671     } catch (std::out_of_range& e) {
74672       {
74673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74674       };
74675     } catch (std::exception& e) {
74676       {
74677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74678       };
74679     } catch (...) {
74680       {
74681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74682       };
74683     }
74684   }
74685 }
74686
74687
74688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74690
74691   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74692   {
74693     try {
74694       (arg1)->RemoveConstraintsFromChildren();
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74706       };
74707     }
74708   }
74709 }
74710
74711
74712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74714   Dali::Toolkit::ScrollViewEffect arg2 ;
74715   Dali::Toolkit::ScrollViewEffect *argp2 ;
74716
74717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74718   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74719   if (!argp2) {
74720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74721     return ;
74722   }
74723   arg2 = *argp2;
74724   {
74725     try {
74726       (arg1)->ApplyEffect(arg2);
74727     } catch (std::out_of_range& e) {
74728       {
74729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74730       };
74731     } catch (std::exception& e) {
74732       {
74733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74734       };
74735     } catch (...) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74738       };
74739     }
74740   }
74741 }
74742
74743
74744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74745   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74746   Dali::Toolkit::ScrollViewEffect arg2 ;
74747   Dali::Toolkit::ScrollViewEffect *argp2 ;
74748
74749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74750   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74751   if (!argp2) {
74752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74753     return ;
74754   }
74755   arg2 = *argp2;
74756   {
74757     try {
74758       (arg1)->RemoveEffect(arg2);
74759     } catch (std::out_of_range& e) {
74760       {
74761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74762       };
74763     } catch (std::exception& e) {
74764       {
74765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74766       };
74767     } catch (...) {
74768       {
74769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74770       };
74771     }
74772   }
74773 }
74774
74775
74776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74778
74779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74780   {
74781     try {
74782       (arg1)->RemoveAllEffects();
74783     } catch (std::out_of_range& e) {
74784       {
74785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74786       };
74787     } catch (std::exception& e) {
74788       {
74789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74790       };
74791     } catch (...) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74794       };
74795     }
74796   }
74797 }
74798
74799
74800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74802   Dali::Actor arg2 ;
74803   Dali::Actor *argp2 ;
74804
74805   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74806   argp2 = (Dali::Actor *)jarg2;
74807   if (!argp2) {
74808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74809     return ;
74810   }
74811   arg2 = *argp2;
74812   {
74813     try {
74814       (arg1)->BindActor(arg2);
74815     } catch (std::out_of_range& e) {
74816       {
74817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74818       };
74819     } catch (std::exception& e) {
74820       {
74821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74822       };
74823     } catch (...) {
74824       {
74825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74826       };
74827     }
74828   }
74829 }
74830
74831
74832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74833   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74834   Dali::Actor arg2 ;
74835   Dali::Actor *argp2 ;
74836
74837   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74838   argp2 = (Dali::Actor *)jarg2;
74839   if (!argp2) {
74840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74841     return ;
74842   }
74843   arg2 = *argp2;
74844   {
74845     try {
74846       (arg1)->UnbindActor(arg2);
74847     } catch (std::out_of_range& e) {
74848       {
74849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74850       };
74851     } catch (std::exception& e) {
74852       {
74853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74854       };
74855     } catch (...) {
74856       {
74857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74858       };
74859     }
74860   }
74861 }
74862
74863
74864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74866   Dali::Radian arg2 ;
74867   Dali::Radian arg3 ;
74868   Dali::Radian *argp2 ;
74869   Dali::Radian *argp3 ;
74870
74871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74872   argp2 = (Dali::Radian *)jarg2;
74873   if (!argp2) {
74874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74875     return ;
74876   }
74877   arg2 = *argp2;
74878   argp3 = (Dali::Radian *)jarg3;
74879   if (!argp3) {
74880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74881     return ;
74882   }
74883   arg3 = *argp3;
74884   {
74885     try {
74886       (arg1)->SetScrollingDirection(arg2,arg3);
74887     } catch (std::out_of_range& e) {
74888       {
74889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74890       };
74891     } catch (std::exception& e) {
74892       {
74893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74894       };
74895     } catch (...) {
74896       {
74897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74898       };
74899     }
74900   }
74901 }
74902
74903
74904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74906   Dali::Radian arg2 ;
74907   Dali::Radian *argp2 ;
74908
74909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74910   argp2 = (Dali::Radian *)jarg2;
74911   if (!argp2) {
74912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74913     return ;
74914   }
74915   arg2 = *argp2;
74916   {
74917     try {
74918       (arg1)->SetScrollingDirection(arg2);
74919     } catch (std::out_of_range& e) {
74920       {
74921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74922       };
74923     } catch (std::exception& e) {
74924       {
74925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74930       };
74931     }
74932   }
74933 }
74934
74935
74936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74938   Dali::Radian arg2 ;
74939   Dali::Radian *argp2 ;
74940
74941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74942   argp2 = (Dali::Radian *)jarg2;
74943   if (!argp2) {
74944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74945     return ;
74946   }
74947   arg2 = *argp2;
74948   {
74949     try {
74950       (arg1)->RemoveScrollingDirection(arg2);
74951     } catch (std::out_of_range& e) {
74952       {
74953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74954       };
74955     } catch (std::exception& e) {
74956       {
74957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (...) {
74960       {
74961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74962       };
74963     }
74964   }
74965 }
74966
74967
74968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74969   void * jresult ;
74970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74971   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74972
74973   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74974   {
74975     try {
74976       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74977     } catch (std::out_of_range& e) {
74978       {
74979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74980       };
74981     } catch (std::exception& e) {
74982       {
74983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (...) {
74986       {
74987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74988       };
74989     }
74990   }
74991   jresult = (void *)result;
74992   return jresult;
74993 }
74994
74995
74996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
74997   int jresult ;
74998   int result;
74999
75000   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75001   jresult = (int)result;
75002   return jresult;
75003 }
75004
75005
75006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75007   int jresult ;
75008   int result;
75009
75010   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75011   jresult = (int)result;
75012   return jresult;
75013 }
75014
75015
75016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75017   int jresult ;
75018   int result;
75019
75020   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75021   jresult = (int)result;
75022   return jresult;
75023 }
75024
75025
75026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75027   int jresult ;
75028   int result;
75029
75030   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75031   jresult = (int)result;
75032   return jresult;
75033 }
75034
75035
75036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75037   int jresult ;
75038   int result;
75039
75040   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75041   jresult = (int)result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75047   void * jresult ;
75048   Dali::Toolkit::TableView::Property *result = 0 ;
75049
75050   {
75051     try {
75052       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75053     } catch (std::out_of_range& e) {
75054       {
75055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75056       };
75057     } catch (std::exception& e) {
75058       {
75059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75060       };
75061     } catch (...) {
75062       {
75063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75064       };
75065     }
75066   }
75067   jresult = (void *)result;
75068   return jresult;
75069 }
75070
75071
75072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75073   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75074
75075   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75076   {
75077     try {
75078       delete arg1;
75079     } catch (std::out_of_range& e) {
75080       {
75081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75082       };
75083     } catch (std::exception& e) {
75084       {
75085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75086       };
75087     } catch (...) {
75088       {
75089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75090       };
75091     }
75092   }
75093 }
75094
75095
75096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75097   int jresult ;
75098   int result;
75099
75100   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75101   jresult = (int)result;
75102   return jresult;
75103 }
75104
75105
75106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75107   int jresult ;
75108   int result;
75109
75110   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75111   jresult = (int)result;
75112   return jresult;
75113 }
75114
75115
75116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75117   int jresult ;
75118   int result;
75119
75120   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75121   jresult = (int)result;
75122   return jresult;
75123 }
75124
75125
75126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75127   int jresult ;
75128   int result;
75129
75130   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75131   jresult = (int)result;
75132   return jresult;
75133 }
75134
75135
75136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75137   int jresult ;
75138   int result;
75139
75140   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75141   jresult = (int)result;
75142   return jresult;
75143 }
75144
75145
75146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75147   void * jresult ;
75148   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75149
75150   {
75151     try {
75152       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75153     } catch (std::out_of_range& e) {
75154       {
75155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75156       };
75157     } catch (std::exception& e) {
75158       {
75159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (...) {
75162       {
75163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75164       };
75165     }
75166   }
75167   jresult = (void *)result;
75168   return jresult;
75169 }
75170
75171
75172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75173   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75174
75175   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75176   {
75177     try {
75178       delete arg1;
75179     } catch (std::out_of_range& e) {
75180       {
75181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75182       };
75183     } catch (std::exception& e) {
75184       {
75185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75186       };
75187     } catch (...) {
75188       {
75189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75190       };
75191     }
75192   }
75193 }
75194
75195
75196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75197   void * jresult ;
75198   unsigned int arg1 ;
75199   unsigned int arg2 ;
75200   unsigned int arg3 ;
75201   unsigned int arg4 ;
75202   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75203
75204   arg1 = (unsigned int)jarg1;
75205   arg2 = (unsigned int)jarg2;
75206   arg3 = (unsigned int)jarg3;
75207   arg4 = (unsigned int)jarg4;
75208   {
75209     try {
75210       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (...) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75222       };
75223     }
75224   }
75225   jresult = (void *)result;
75226   return jresult;
75227 }
75228
75229
75230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75231   void * jresult ;
75232   unsigned int arg1 ;
75233   unsigned int arg2 ;
75234   unsigned int arg3 ;
75235   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75236
75237   arg1 = (unsigned int)jarg1;
75238   arg2 = (unsigned int)jarg2;
75239   arg3 = (unsigned int)jarg3;
75240   {
75241     try {
75242       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75243     } catch (std::out_of_range& e) {
75244       {
75245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75246       };
75247     } catch (std::exception& e) {
75248       {
75249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75250       };
75251     } catch (...) {
75252       {
75253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75254       };
75255     }
75256   }
75257   jresult = (void *)result;
75258   return jresult;
75259 }
75260
75261
75262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75263   void * jresult ;
75264   unsigned int arg1 ;
75265   unsigned int arg2 ;
75266   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75267
75268   arg1 = (unsigned int)jarg1;
75269   arg2 = (unsigned int)jarg2;
75270   {
75271     try {
75272       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75273     } catch (std::out_of_range& e) {
75274       {
75275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75276       };
75277     } catch (std::exception& e) {
75278       {
75279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75280       };
75281     } catch (...) {
75282       {
75283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75284       };
75285     }
75286   }
75287   jresult = (void *)result;
75288   return jresult;
75289 }
75290
75291
75292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75293   void * jresult ;
75294   unsigned int arg1 ;
75295   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75296
75297   arg1 = (unsigned int)jarg1;
75298   {
75299     try {
75300       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75301     } catch (std::out_of_range& e) {
75302       {
75303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75304       };
75305     } catch (std::exception& e) {
75306       {
75307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75308       };
75309     } catch (...) {
75310       {
75311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75312       };
75313     }
75314   }
75315   jresult = (void *)result;
75316   return jresult;
75317 }
75318
75319
75320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75321   void * jresult ;
75322   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75323
75324   {
75325     try {
75326       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75327     } catch (std::out_of_range& e) {
75328       {
75329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75330       };
75331     } catch (std::exception& e) {
75332       {
75333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75334       };
75335     } catch (...) {
75336       {
75337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75338       };
75339     }
75340   }
75341   jresult = (void *)result;
75342   return jresult;
75343 }
75344
75345
75346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75347   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75348   unsigned int arg2 ;
75349
75350   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75351   arg2 = (unsigned int)jarg2;
75352   if (arg1) (arg1)->rowIndex = arg2;
75353 }
75354
75355
75356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75357   unsigned int jresult ;
75358   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75359   unsigned int result;
75360
75361   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75362   result = (unsigned int) ((arg1)->rowIndex);
75363   jresult = result;
75364   return jresult;
75365 }
75366
75367
75368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75369   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75370   unsigned int arg2 ;
75371
75372   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75373   arg2 = (unsigned int)jarg2;
75374   if (arg1) (arg1)->columnIndex = arg2;
75375 }
75376
75377
75378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75379   unsigned int jresult ;
75380   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75381   unsigned int result;
75382
75383   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75384   result = (unsigned int) ((arg1)->columnIndex);
75385   jresult = result;
75386   return jresult;
75387 }
75388
75389
75390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75391   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75392   unsigned int arg2 ;
75393
75394   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75395   arg2 = (unsigned int)jarg2;
75396   if (arg1) (arg1)->rowSpan = arg2;
75397 }
75398
75399
75400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75401   unsigned int jresult ;
75402   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75403   unsigned int result;
75404
75405   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75406   result = (unsigned int) ((arg1)->rowSpan);
75407   jresult = result;
75408   return jresult;
75409 }
75410
75411
75412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75413   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75414   unsigned int arg2 ;
75415
75416   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75417   arg2 = (unsigned int)jarg2;
75418   if (arg1) (arg1)->columnSpan = arg2;
75419 }
75420
75421
75422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75423   unsigned int jresult ;
75424   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75425   unsigned int result;
75426
75427   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75428   result = (unsigned int) ((arg1)->columnSpan);
75429   jresult = result;
75430   return jresult;
75431 }
75432
75433
75434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75435   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75436
75437   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75438   {
75439     try {
75440       delete arg1;
75441     } catch (std::out_of_range& e) {
75442       {
75443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75444       };
75445     } catch (std::exception& e) {
75446       {
75447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75448       };
75449     } catch (...) {
75450       {
75451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75452       };
75453     }
75454   }
75455 }
75456
75457
75458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75459   void * jresult ;
75460   Dali::Toolkit::TableView *result = 0 ;
75461
75462   {
75463     try {
75464       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75465     } catch (std::out_of_range& e) {
75466       {
75467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75468       };
75469     } catch (std::exception& e) {
75470       {
75471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75476       };
75477     }
75478   }
75479   jresult = (void *)result;
75480   return jresult;
75481 }
75482
75483
75484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75485   void * jresult ;
75486   Dali::Toolkit::TableView *arg1 = 0 ;
75487   Dali::Toolkit::TableView *result = 0 ;
75488
75489   arg1 = (Dali::Toolkit::TableView *)jarg1;
75490   if (!arg1) {
75491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75492     return 0;
75493   }
75494   {
75495     try {
75496       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75497     } catch (std::out_of_range& e) {
75498       {
75499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75500       };
75501     } catch (std::exception& e) {
75502       {
75503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75504       };
75505     } catch (...) {
75506       {
75507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75508       };
75509     }
75510   }
75511   jresult = (void *)result;
75512   return jresult;
75513 }
75514
75515
75516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75517   void * jresult ;
75518   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75519   Dali::Toolkit::TableView *arg2 = 0 ;
75520   Dali::Toolkit::TableView *result = 0 ;
75521
75522   arg1 = (Dali::Toolkit::TableView *)jarg1;
75523   arg2 = (Dali::Toolkit::TableView *)jarg2;
75524   if (!arg2) {
75525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75526     return 0;
75527   }
75528   {
75529     try {
75530       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75531     } catch (std::out_of_range& e) {
75532       {
75533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75534       };
75535     } catch (std::exception& e) {
75536       {
75537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75538       };
75539     } catch (...) {
75540       {
75541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75542       };
75543     }
75544   }
75545   jresult = (void *)result;
75546   return jresult;
75547 }
75548
75549
75550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75551   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75552
75553   arg1 = (Dali::Toolkit::TableView *)jarg1;
75554   {
75555     try {
75556       delete arg1;
75557     } catch (std::out_of_range& e) {
75558       {
75559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75560       };
75561     } catch (std::exception& e) {
75562       {
75563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75564       };
75565     } catch (...) {
75566       {
75567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75568       };
75569     }
75570   }
75571 }
75572
75573
75574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75575   void * jresult ;
75576   unsigned int arg1 ;
75577   unsigned int arg2 ;
75578   Dali::Toolkit::TableView result;
75579
75580   arg1 = (unsigned int)jarg1;
75581   arg2 = (unsigned int)jarg2;
75582   {
75583     try {
75584       result = Dali::Toolkit::TableView::New(arg1,arg2);
75585     } catch (std::out_of_range& e) {
75586       {
75587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (std::exception& e) {
75590       {
75591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75592       };
75593     } catch (...) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75596       };
75597     }
75598   }
75599   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75600   return jresult;
75601 }
75602
75603
75604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75605   void * jresult ;
75606   Dali::BaseHandle arg1 ;
75607   Dali::BaseHandle *argp1 ;
75608   Dali::Toolkit::TableView result;
75609
75610   argp1 = (Dali::BaseHandle *)jarg1;
75611   if (!argp1) {
75612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75613     return 0;
75614   }
75615   arg1 = *argp1;
75616   {
75617     try {
75618       result = Dali::Toolkit::TableView::DownCast(arg1);
75619     } catch (std::out_of_range& e) {
75620       {
75621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75622       };
75623     } catch (std::exception& e) {
75624       {
75625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75626       };
75627     } catch (...) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75630       };
75631     }
75632   }
75633   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75634   return jresult;
75635 }
75636
75637
75638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75639   unsigned int jresult ;
75640   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75641   Dali::Actor arg2 ;
75642   Dali::Toolkit::TableView::CellPosition arg3 ;
75643   Dali::Actor *argp2 ;
75644   Dali::Toolkit::TableView::CellPosition *argp3 ;
75645   bool result;
75646
75647   arg1 = (Dali::Toolkit::TableView *)jarg1;
75648   argp2 = (Dali::Actor *)jarg2;
75649   if (!argp2) {
75650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75651     return 0;
75652   }
75653   arg2 = *argp2;
75654   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75655   if (!argp3) {
75656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75657     return 0;
75658   }
75659   arg3 = *argp3;
75660   {
75661     try {
75662       result = (bool)(arg1)->AddChild(arg2,arg3);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75674       };
75675     }
75676   }
75677   jresult = result;
75678   return jresult;
75679 }
75680
75681
75682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75683   void * jresult ;
75684   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75685   Dali::Toolkit::TableView::CellPosition arg2 ;
75686   Dali::Toolkit::TableView::CellPosition *argp2 ;
75687   Dali::Actor result;
75688
75689   arg1 = (Dali::Toolkit::TableView *)jarg1;
75690   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75691   if (!argp2) {
75692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75693     return 0;
75694   }
75695   arg2 = *argp2;
75696   {
75697     try {
75698       result = (arg1)->GetChildAt(arg2);
75699     } catch (std::out_of_range& e) {
75700       {
75701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75702       };
75703     } catch (std::exception& e) {
75704       {
75705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75706       };
75707     } catch (...) {
75708       {
75709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75710       };
75711     }
75712   }
75713   jresult = new Dali::Actor((const Dali::Actor &)result);
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75719   void * jresult ;
75720   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75721   Dali::Toolkit::TableView::CellPosition arg2 ;
75722   Dali::Toolkit::TableView::CellPosition *argp2 ;
75723   Dali::Actor result;
75724
75725   arg1 = (Dali::Toolkit::TableView *)jarg1;
75726   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75727   if (!argp2) {
75728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75729     return 0;
75730   }
75731   arg2 = *argp2;
75732   {
75733     try {
75734       result = (arg1)->RemoveChildAt(arg2);
75735     } catch (std::out_of_range& e) {
75736       {
75737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75738       };
75739     } catch (std::exception& e) {
75740       {
75741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75742       };
75743     } catch (...) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75746       };
75747     }
75748   }
75749   jresult = new Dali::Actor((const Dali::Actor &)result);
75750   return jresult;
75751 }
75752
75753
75754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75755   unsigned int jresult ;
75756   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75757   Dali::Actor arg2 ;
75758   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75759   Dali::Actor *argp2 ;
75760   bool result;
75761
75762   arg1 = (Dali::Toolkit::TableView *)jarg1;
75763   argp2 = (Dali::Actor *)jarg2;
75764   if (!argp2) {
75765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75766     return 0;
75767   }
75768   arg2 = *argp2;
75769   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75770   if (!arg3) {
75771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75772     return 0;
75773   }
75774   {
75775     try {
75776       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75777     } catch (std::out_of_range& e) {
75778       {
75779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75780       };
75781     } catch (std::exception& e) {
75782       {
75783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75784       };
75785     } catch (...) {
75786       {
75787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75788       };
75789     }
75790   }
75791   jresult = result;
75792   return jresult;
75793 }
75794
75795
75796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75797   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75798   unsigned int arg2 ;
75799
75800   arg1 = (Dali::Toolkit::TableView *)jarg1;
75801   arg2 = (unsigned int)jarg2;
75802   {
75803     try {
75804       (arg1)->InsertRow(arg2);
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75816       };
75817     }
75818   }
75819 }
75820
75821
75822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75823   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75824   unsigned int arg2 ;
75825
75826   arg1 = (Dali::Toolkit::TableView *)jarg1;
75827   arg2 = (unsigned int)jarg2;
75828   {
75829     try {
75830       (arg1)->DeleteRow(arg2);
75831     } catch (std::out_of_range& e) {
75832       {
75833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75834       };
75835     } catch (std::exception& e) {
75836       {
75837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75838       };
75839     } catch (...) {
75840       {
75841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75842       };
75843     }
75844   }
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75849   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75850   unsigned int arg2 ;
75851   std::vector< Dali::Actor > *arg3 = 0 ;
75852
75853   arg1 = (Dali::Toolkit::TableView *)jarg1;
75854   arg2 = (unsigned int)jarg2;
75855   arg3 = (std::vector< Dali::Actor > *)jarg3;
75856   if (!arg3) {
75857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75858     return ;
75859   }
75860   {
75861     try {
75862       (arg1)->DeleteRow(arg2,*arg3);
75863     } catch (std::out_of_range& e) {
75864       {
75865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75866       };
75867     } catch (std::exception& e) {
75868       {
75869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75870       };
75871     } catch (...) {
75872       {
75873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75874       };
75875     }
75876   }
75877 }
75878
75879
75880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75881   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75882   unsigned int arg2 ;
75883
75884   arg1 = (Dali::Toolkit::TableView *)jarg1;
75885   arg2 = (unsigned int)jarg2;
75886   {
75887     try {
75888       (arg1)->InsertColumn(arg2);
75889     } catch (std::out_of_range& e) {
75890       {
75891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75892       };
75893     } catch (std::exception& e) {
75894       {
75895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75900       };
75901     }
75902   }
75903 }
75904
75905
75906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75907   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75908   unsigned int arg2 ;
75909
75910   arg1 = (Dali::Toolkit::TableView *)jarg1;
75911   arg2 = (unsigned int)jarg2;
75912   {
75913     try {
75914       (arg1)->DeleteColumn(arg2);
75915     } catch (std::out_of_range& e) {
75916       {
75917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75918       };
75919     } catch (std::exception& e) {
75920       {
75921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75922       };
75923     } catch (...) {
75924       {
75925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75926       };
75927     }
75928   }
75929 }
75930
75931
75932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75933   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75934   unsigned int arg2 ;
75935   std::vector< Dali::Actor > *arg3 = 0 ;
75936
75937   arg1 = (Dali::Toolkit::TableView *)jarg1;
75938   arg2 = (unsigned int)jarg2;
75939   arg3 = (std::vector< Dali::Actor > *)jarg3;
75940   if (!arg3) {
75941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75942     return ;
75943   }
75944   {
75945     try {
75946       (arg1)->DeleteColumn(arg2,*arg3);
75947     } catch (std::out_of_range& e) {
75948       {
75949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75950       };
75951     } catch (std::exception& e) {
75952       {
75953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75954       };
75955     } catch (...) {
75956       {
75957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75958       };
75959     }
75960   }
75961 }
75962
75963
75964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75965   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75966   unsigned int arg2 ;
75967   unsigned int arg3 ;
75968
75969   arg1 = (Dali::Toolkit::TableView *)jarg1;
75970   arg2 = (unsigned int)jarg2;
75971   arg3 = (unsigned int)jarg3;
75972   {
75973     try {
75974       (arg1)->Resize(arg2,arg3);
75975     } catch (std::out_of_range& e) {
75976       {
75977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75978       };
75979     } catch (std::exception& e) {
75980       {
75981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75982       };
75983     } catch (...) {
75984       {
75985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75986       };
75987     }
75988   }
75989 }
75990
75991
75992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
75993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75994   unsigned int arg2 ;
75995   unsigned int arg3 ;
75996   std::vector< Dali::Actor > *arg4 = 0 ;
75997
75998   arg1 = (Dali::Toolkit::TableView *)jarg1;
75999   arg2 = (unsigned int)jarg2;
76000   arg3 = (unsigned int)jarg3;
76001   arg4 = (std::vector< Dali::Actor > *)jarg4;
76002   if (!arg4) {
76003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76004     return ;
76005   }
76006   {
76007     try {
76008       (arg1)->Resize(arg2,arg3,*arg4);
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76020       };
76021     }
76022   }
76023 }
76024
76025
76026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76027   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76028   Dali::Size arg2 ;
76029   Dali::Size *argp2 ;
76030
76031   arg1 = (Dali::Toolkit::TableView *)jarg1;
76032   argp2 = (Dali::Size *)jarg2;
76033   if (!argp2) {
76034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76035     return ;
76036   }
76037   arg2 = *argp2;
76038   {
76039     try {
76040       (arg1)->SetCellPadding(arg2);
76041     } catch (std::out_of_range& e) {
76042       {
76043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76044       };
76045     } catch (std::exception& e) {
76046       {
76047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76048       };
76049     } catch (...) {
76050       {
76051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76052       };
76053     }
76054   }
76055 }
76056
76057
76058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76059   void * jresult ;
76060   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76061   Dali::Size result;
76062
76063   arg1 = (Dali::Toolkit::TableView *)jarg1;
76064   {
76065     try {
76066       result = (arg1)->GetCellPadding();
76067     } catch (std::out_of_range& e) {
76068       {
76069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76070       };
76071     } catch (std::exception& e) {
76072       {
76073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76074       };
76075     } catch (...) {
76076       {
76077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76078       };
76079     }
76080   }
76081   jresult = new Dali::Size((const Dali::Size &)result);
76082   return jresult;
76083 }
76084
76085
76086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76087   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76088   unsigned int arg2 ;
76089
76090   arg1 = (Dali::Toolkit::TableView *)jarg1;
76091   arg2 = (unsigned int)jarg2;
76092   {
76093     try {
76094       (arg1)->SetFitHeight(arg2);
76095     } catch (std::out_of_range& e) {
76096       {
76097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76098       };
76099     } catch (std::exception& e) {
76100       {
76101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76102       };
76103     } catch (...) {
76104       {
76105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76106       };
76107     }
76108   }
76109 }
76110
76111
76112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76113   unsigned int jresult ;
76114   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76115   unsigned int arg2 ;
76116   bool result;
76117
76118   arg1 = (Dali::Toolkit::TableView *)jarg1;
76119   arg2 = (unsigned int)jarg2;
76120   {
76121     try {
76122       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76123     } catch (std::out_of_range& e) {
76124       {
76125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76126       };
76127     } catch (std::exception& e) {
76128       {
76129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76130       };
76131     } catch (...) {
76132       {
76133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76134       };
76135     }
76136   }
76137   jresult = result;
76138   return jresult;
76139 }
76140
76141
76142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76143   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76144   unsigned int arg2 ;
76145
76146   arg1 = (Dali::Toolkit::TableView *)jarg1;
76147   arg2 = (unsigned int)jarg2;
76148   {
76149     try {
76150       (arg1)->SetFitWidth(arg2);
76151     } catch (std::out_of_range& e) {
76152       {
76153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76154       };
76155     } catch (std::exception& e) {
76156       {
76157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76162       };
76163     }
76164   }
76165 }
76166
76167
76168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76169   unsigned int jresult ;
76170   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76171   unsigned int arg2 ;
76172   bool result;
76173
76174   arg1 = (Dali::Toolkit::TableView *)jarg1;
76175   arg2 = (unsigned int)jarg2;
76176   {
76177     try {
76178       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76179     } catch (std::out_of_range& e) {
76180       {
76181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76182       };
76183     } catch (std::exception& e) {
76184       {
76185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76186       };
76187     } catch (...) {
76188       {
76189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76190       };
76191     }
76192   }
76193   jresult = result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76199   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76200   unsigned int arg2 ;
76201   float arg3 ;
76202
76203   arg1 = (Dali::Toolkit::TableView *)jarg1;
76204   arg2 = (unsigned int)jarg2;
76205   arg3 = (float)jarg3;
76206   {
76207     try {
76208       (arg1)->SetFixedHeight(arg2,arg3);
76209     } catch (std::out_of_range& e) {
76210       {
76211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76212       };
76213     } catch (std::exception& e) {
76214       {
76215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76216       };
76217     } catch (...) {
76218       {
76219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76220       };
76221     }
76222   }
76223 }
76224
76225
76226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76227   float jresult ;
76228   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76229   unsigned int arg2 ;
76230   float result;
76231
76232   arg1 = (Dali::Toolkit::TableView *)jarg1;
76233   arg2 = (unsigned int)jarg2;
76234   {
76235     try {
76236       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76237     } catch (std::out_of_range& e) {
76238       {
76239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76240       };
76241     } catch (std::exception& e) {
76242       {
76243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76244       };
76245     } catch (...) {
76246       {
76247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76248       };
76249     }
76250   }
76251   jresult = result;
76252   return jresult;
76253 }
76254
76255
76256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76257   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76258   unsigned int arg2 ;
76259   float arg3 ;
76260
76261   arg1 = (Dali::Toolkit::TableView *)jarg1;
76262   arg2 = (unsigned int)jarg2;
76263   arg3 = (float)jarg3;
76264   {
76265     try {
76266       (arg1)->SetRelativeHeight(arg2,arg3);
76267     } catch (std::out_of_range& e) {
76268       {
76269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76270       };
76271     } catch (std::exception& e) {
76272       {
76273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76274       };
76275     } catch (...) {
76276       {
76277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76278       };
76279     }
76280   }
76281 }
76282
76283
76284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76285   float jresult ;
76286   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76287   unsigned int arg2 ;
76288   float result;
76289
76290   arg1 = (Dali::Toolkit::TableView *)jarg1;
76291   arg2 = (unsigned int)jarg2;
76292   {
76293     try {
76294       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76295     } catch (std::out_of_range& e) {
76296       {
76297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76298       };
76299     } catch (std::exception& e) {
76300       {
76301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76302       };
76303     } catch (...) {
76304       {
76305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76306       };
76307     }
76308   }
76309   jresult = result;
76310   return jresult;
76311 }
76312
76313
76314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76315   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76316   unsigned int arg2 ;
76317   float arg3 ;
76318
76319   arg1 = (Dali::Toolkit::TableView *)jarg1;
76320   arg2 = (unsigned int)jarg2;
76321   arg3 = (float)jarg3;
76322   {
76323     try {
76324       (arg1)->SetFixedWidth(arg2,arg3);
76325     } catch (std::out_of_range& e) {
76326       {
76327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76328       };
76329     } catch (std::exception& e) {
76330       {
76331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76336       };
76337     }
76338   }
76339 }
76340
76341
76342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76343   float jresult ;
76344   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76345   unsigned int arg2 ;
76346   float result;
76347
76348   arg1 = (Dali::Toolkit::TableView *)jarg1;
76349   arg2 = (unsigned int)jarg2;
76350   {
76351     try {
76352       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76360       };
76361     } catch (...) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76364       };
76365     }
76366   }
76367   jresult = result;
76368   return jresult;
76369 }
76370
76371
76372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76373   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76374   unsigned int arg2 ;
76375   float arg3 ;
76376
76377   arg1 = (Dali::Toolkit::TableView *)jarg1;
76378   arg2 = (unsigned int)jarg2;
76379   arg3 = (float)jarg3;
76380   {
76381     try {
76382       (arg1)->SetRelativeWidth(arg2,arg3);
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76390       };
76391     } catch (...) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76394       };
76395     }
76396   }
76397 }
76398
76399
76400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76401   float jresult ;
76402   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76403   unsigned int arg2 ;
76404   float result;
76405
76406   arg1 = (Dali::Toolkit::TableView *)jarg1;
76407   arg2 = (unsigned int)jarg2;
76408   {
76409     try {
76410       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76411     } catch (std::out_of_range& e) {
76412       {
76413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76414       };
76415     } catch (std::exception& e) {
76416       {
76417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76418       };
76419     } catch (...) {
76420       {
76421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76422       };
76423     }
76424   }
76425   jresult = result;
76426   return jresult;
76427 }
76428
76429
76430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76431   unsigned int jresult ;
76432   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76433   unsigned int result;
76434
76435   arg1 = (Dali::Toolkit::TableView *)jarg1;
76436   {
76437     try {
76438       result = (unsigned int)(arg1)->GetRows();
76439     } catch (std::out_of_range& e) {
76440       {
76441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (std::exception& e) {
76444       {
76445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76450       };
76451     }
76452   }
76453   jresult = result;
76454   return jresult;
76455 }
76456
76457
76458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76459   unsigned int jresult ;
76460   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76461   unsigned int result;
76462
76463   arg1 = (Dali::Toolkit::TableView *)jarg1;
76464   {
76465     try {
76466       result = (unsigned int)(arg1)->GetColumns();
76467     } catch (std::out_of_range& e) {
76468       {
76469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76470       };
76471     } catch (std::exception& e) {
76472       {
76473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76474       };
76475     } catch (...) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76478       };
76479     }
76480   }
76481   jresult = result;
76482   return jresult;
76483 }
76484
76485
76486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76487   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76488   Dali::Toolkit::TableView::CellPosition arg2 ;
76489   Dali::HorizontalAlignment::Type arg3 ;
76490   Dali::VerticalAlignment::Type arg4 ;
76491   Dali::Toolkit::TableView::CellPosition *argp2 ;
76492
76493   arg1 = (Dali::Toolkit::TableView *)jarg1;
76494   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76495   if (!argp2) {
76496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76497     return ;
76498   }
76499   arg2 = *argp2;
76500   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76501   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76502   {
76503     try {
76504       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76505     } catch (std::out_of_range& e) {
76506       {
76507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76508       };
76509     } catch (std::exception& e) {
76510       {
76511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76512       };
76513     } catch (...) {
76514       {
76515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76516       };
76517     }
76518   }
76519 }
76520
76521
76522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76523   unsigned int jresult ;
76524   unsigned int result;
76525
76526   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76527   jresult = result;
76528   return jresult;
76529 }
76530
76531
76532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76533   int jresult ;
76534   int result;
76535
76536   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76537   jresult = (int)result;
76538   return jresult;
76539 }
76540
76541
76542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76543   int jresult ;
76544   int result;
76545
76546   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76547   jresult = (int)result;
76548   return jresult;
76549 }
76550
76551
76552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76553   int jresult ;
76554   int result;
76555
76556   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76557   jresult = (int)result;
76558   return jresult;
76559 }
76560
76561
76562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76563   int jresult ;
76564   int result;
76565
76566   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76567   jresult = (int)result;
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76573   int jresult ;
76574   int result;
76575
76576   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76577   jresult = (int)result;
76578   return jresult;
76579 }
76580
76581
76582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76583   int jresult ;
76584   int result;
76585
76586   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76587   jresult = (int)result;
76588   return jresult;
76589 }
76590
76591
76592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76593   int jresult ;
76594   int result;
76595
76596   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76597   jresult = (int)result;
76598   return jresult;
76599 }
76600
76601
76602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76603   int jresult ;
76604   int result;
76605
76606   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76607   jresult = (int)result;
76608   return jresult;
76609 }
76610
76611
76612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76613   int jresult ;
76614   int result;
76615
76616   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76617   jresult = (int)result;
76618   return jresult;
76619 }
76620
76621
76622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76623   int jresult ;
76624   int result;
76625
76626   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76627   jresult = (int)result;
76628   return jresult;
76629 }
76630
76631
76632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76633   int jresult ;
76634   int result;
76635
76636   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76637   jresult = (int)result;
76638   return jresult;
76639 }
76640
76641
76642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76643   int jresult ;
76644   int result;
76645
76646   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76647   jresult = (int)result;
76648   return jresult;
76649 }
76650
76651
76652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76653   int jresult ;
76654   int result;
76655
76656   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76657   jresult = (int)result;
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76663   int jresult ;
76664   int result;
76665
76666   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76667   jresult = (int)result;
76668   return jresult;
76669 }
76670
76671
76672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76673   int jresult ;
76674   int result;
76675
76676   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76677   jresult = (int)result;
76678   return jresult;
76679 }
76680
76681
76682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76683   int jresult ;
76684   int result;
76685
76686   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76687   jresult = (int)result;
76688   return jresult;
76689 }
76690
76691
76692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76693   int jresult ;
76694   int result;
76695
76696   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76697   jresult = (int)result;
76698   return jresult;
76699 }
76700
76701
76702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76703   int jresult ;
76704   int result;
76705
76706   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76707   jresult = (int)result;
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76713   int jresult ;
76714   int result;
76715
76716   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76717   jresult = (int)result;
76718   return jresult;
76719 }
76720
76721
76722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76723   int jresult ;
76724   int result;
76725
76726   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76727   jresult = (int)result;
76728   return jresult;
76729 }
76730
76731
76732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76733   int jresult ;
76734   int result;
76735
76736   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76737   jresult = (int)result;
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76743   int jresult ;
76744   int result;
76745
76746   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76747   jresult = (int)result;
76748   return jresult;
76749 }
76750
76751
76752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76753   int jresult ;
76754   int result;
76755
76756   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76757   jresult = (int)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76763   int jresult ;
76764   int result;
76765
76766   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76767   jresult = (int)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76773   int jresult ;
76774   int result;
76775
76776   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76777   jresult = (int)result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76783   int jresult ;
76784   int result;
76785
76786   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76787   jresult = (int)result;
76788   return jresult;
76789 }
76790
76791
76792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76793   int jresult ;
76794   int result;
76795
76796   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76797   jresult = (int)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76803   int jresult ;
76804   int result;
76805
76806   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76807   jresult = (int)result;
76808   return jresult;
76809 }
76810
76811
76812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76813   int jresult ;
76814   int result;
76815
76816   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76817   jresult = (int)result;
76818   return jresult;
76819 }
76820
76821
76822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76823   int jresult ;
76824   int result;
76825
76826   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76827   jresult = (int)result;
76828   return jresult;
76829 }
76830
76831
76832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76833   int jresult ;
76834   int result;
76835
76836   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76837   jresult = (int)result;
76838   return jresult;
76839 }
76840
76841
76842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76843   int jresult ;
76844   int result;
76845
76846   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76847   jresult = (int)result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76853   int jresult ;
76854   int result;
76855
76856   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76857   jresult = (int)result;
76858   return jresult;
76859 }
76860
76861
76862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76863   int jresult ;
76864   int result;
76865
76866   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76867   jresult = (int)result;
76868   return jresult;
76869 }
76870
76871
76872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76873   int jresult ;
76874   int result;
76875
76876   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76877   jresult = (int)result;
76878   return jresult;
76879 }
76880
76881
76882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76883   int jresult ;
76884   int result;
76885
76886   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76887   jresult = (int)result;
76888   return jresult;
76889 }
76890
76891
76892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76893   int jresult ;
76894   int result;
76895
76896   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76897   jresult = (int)result;
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76903   int jresult ;
76904   int result;
76905
76906   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76907   jresult = (int)result;
76908   return jresult;
76909 }
76910
76911
76912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76913   int jresult ;
76914   int result;
76915
76916   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76917   jresult = (int)result;
76918   return jresult;
76919 }
76920
76921
76922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76923   int jresult ;
76924   int result;
76925
76926   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76927   jresult = (int)result;
76928   return jresult;
76929 }
76930
76931
76932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76933   void * jresult ;
76934   Dali::Toolkit::TextEditor::Property *result = 0 ;
76935
76936   {
76937     try {
76938       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
76939     } catch (std::out_of_range& e) {
76940       {
76941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76942       };
76943     } catch (std::exception& e) {
76944       {
76945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76946       };
76947     } catch (...) {
76948       {
76949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76950       };
76951     }
76952   }
76953   jresult = (void *)result;
76954   return jresult;
76955 }
76956
76957
76958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76959   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76960
76961   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76962   {
76963     try {
76964       delete arg1;
76965     } catch (std::out_of_range& e) {
76966       {
76967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76968       };
76969     } catch (std::exception& e) {
76970       {
76971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76972       };
76973     } catch (...) {
76974       {
76975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76976       };
76977     }
76978   }
76979 }
76980
76981
76982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76983   void * jresult ;
76984   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76985
76986   {
76987     try {
76988       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76989     } catch (std::out_of_range& e) {
76990       {
76991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (std::exception& e) {
76994       {
76995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77000       };
77001     }
77002   }
77003   jresult = (void *)result;
77004   return jresult;
77005 }
77006
77007
77008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77009   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77010
77011   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77012   {
77013     try {
77014       delete arg1;
77015     } catch (std::out_of_range& e) {
77016       {
77017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77018       };
77019     } catch (std::exception& e) {
77020       {
77021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77022       };
77023     } catch (...) {
77024       {
77025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77026       };
77027     }
77028   }
77029 }
77030
77031
77032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77033   void * jresult ;
77034   Dali::Toolkit::TextEditor result;
77035
77036   {
77037     try {
77038       result = Dali::Toolkit::TextEditor::New();
77039     } catch (std::out_of_range& e) {
77040       {
77041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77042       };
77043     } catch (std::exception& e) {
77044       {
77045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77046       };
77047     } catch (...) {
77048       {
77049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77050       };
77051     }
77052   }
77053   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77054   return jresult;
77055 }
77056
77057
77058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77059   void * jresult ;
77060   Dali::Toolkit::TextEditor *result = 0 ;
77061
77062   {
77063     try {
77064       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77065     } catch (std::out_of_range& e) {
77066       {
77067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77068       };
77069     } catch (std::exception& e) {
77070       {
77071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77072       };
77073     } catch (...) {
77074       {
77075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77076       };
77077     }
77078   }
77079   jresult = (void *)result;
77080   return jresult;
77081 }
77082
77083
77084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77085   void * jresult ;
77086   Dali::Toolkit::TextEditor *arg1 = 0 ;
77087   Dali::Toolkit::TextEditor *result = 0 ;
77088
77089   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77090   if (!arg1) {
77091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77092     return 0;
77093   }
77094   {
77095     try {
77096       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77097     } catch (std::out_of_range& e) {
77098       {
77099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77100       };
77101     } catch (std::exception& e) {
77102       {
77103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77104       };
77105     } catch (...) {
77106       {
77107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77108       };
77109     }
77110   }
77111   jresult = (void *)result;
77112   return jresult;
77113 }
77114
77115
77116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77117   void * jresult ;
77118   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77119   Dali::Toolkit::TextEditor *arg2 = 0 ;
77120   Dali::Toolkit::TextEditor *result = 0 ;
77121
77122   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77123   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77124   if (!arg2) {
77125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77126     return 0;
77127   }
77128   {
77129     try {
77130       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77131     } catch (std::out_of_range& e) {
77132       {
77133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77134       };
77135     } catch (std::exception& e) {
77136       {
77137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77138       };
77139     } catch (...) {
77140       {
77141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77142       };
77143     }
77144   }
77145   jresult = (void *)result;
77146   return jresult;
77147 }
77148
77149
77150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77151   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77152
77153   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77154   {
77155     try {
77156       delete arg1;
77157     } catch (std::out_of_range& e) {
77158       {
77159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77160       };
77161     } catch (std::exception& e) {
77162       {
77163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77164       };
77165     } catch (...) {
77166       {
77167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77168       };
77169     }
77170   }
77171 }
77172
77173
77174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77175   void * jresult ;
77176   Dali::BaseHandle arg1 ;
77177   Dali::BaseHandle *argp1 ;
77178   Dali::Toolkit::TextEditor result;
77179
77180   argp1 = (Dali::BaseHandle *)jarg1;
77181   if (!argp1) {
77182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77183     return 0;
77184   }
77185   arg1 = *argp1;
77186   {
77187     try {
77188       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77189     } catch (std::out_of_range& e) {
77190       {
77191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77192       };
77193     } catch (std::exception& e) {
77194       {
77195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77196       };
77197     } catch (...) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77200       };
77201     }
77202   }
77203   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77204   return jresult;
77205 }
77206
77207
77208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77209   void * jresult ;
77210   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77211   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77212
77213   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77214   {
77215     try {
77216       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77217     } catch (std::out_of_range& e) {
77218       {
77219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77220       };
77221     } catch (std::exception& e) {
77222       {
77223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77224       };
77225     } catch (...) {
77226       {
77227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77228       };
77229     }
77230   }
77231   jresult = (void *)result;
77232   return jresult;
77233 }
77234
77235
77236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77237   void * jresult ;
77238   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77239   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77240
77241   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77242   {
77243     try {
77244       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77245     } catch (std::out_of_range& e) {
77246       {
77247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77248       };
77249     } catch (std::exception& e) {
77250       {
77251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77252       };
77253     } catch (...) {
77254       {
77255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77256       };
77257     }
77258   }
77259   jresult = (void *)result;
77260   return jresult;
77261 }
77262
77263
77264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77265   int jresult ;
77266   int result;
77267
77268   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77269   jresult = (int)result;
77270   return jresult;
77271 }
77272
77273
77274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77275   int jresult ;
77276   int result;
77277
77278   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77279   jresult = (int)result;
77280   return jresult;
77281 }
77282
77283
77284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77285   int jresult ;
77286   int result;
77287
77288   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77289   jresult = (int)result;
77290   return jresult;
77291 }
77292
77293
77294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77295   int jresult ;
77296   int result;
77297
77298   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77299   jresult = (int)result;
77300   return jresult;
77301 }
77302
77303
77304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77305   int jresult ;
77306   int result;
77307
77308   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77309   jresult = (int)result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77315   int jresult ;
77316   int result;
77317
77318   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77319   jresult = (int)result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77325   int jresult ;
77326   int result;
77327
77328   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77329   jresult = (int)result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77335   int jresult ;
77336   int result;
77337
77338   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77339   jresult = (int)result;
77340   return jresult;
77341 }
77342
77343
77344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77345   int jresult ;
77346   int result;
77347
77348   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77349   jresult = (int)result;
77350   return jresult;
77351 }
77352
77353
77354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77355   int jresult ;
77356   int result;
77357
77358   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77359   jresult = (int)result;
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77365   int jresult ;
77366   int result;
77367
77368   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77369   jresult = (int)result;
77370   return jresult;
77371 }
77372
77373
77374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77375   int jresult ;
77376   int result;
77377
77378   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77379   jresult = (int)result;
77380   return jresult;
77381 }
77382
77383
77384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77385   int jresult ;
77386   int result;
77387
77388   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77389   jresult = (int)result;
77390   return jresult;
77391 }
77392
77393
77394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77395   int jresult ;
77396   int result;
77397
77398   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77399   jresult = (int)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77405   int jresult ;
77406   int result;
77407
77408   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77415   int jresult ;
77416   int result;
77417
77418   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77419   jresult = (int)result;
77420   return jresult;
77421 }
77422
77423
77424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77425   int jresult ;
77426   int result;
77427
77428   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77429   jresult = (int)result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77435   int jresult ;
77436   int result;
77437
77438   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77439   jresult = (int)result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77445   int jresult ;
77446   int result;
77447
77448   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77449   jresult = (int)result;
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77455   int jresult ;
77456   int result;
77457
77458   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77459   jresult = (int)result;
77460   return jresult;
77461 }
77462
77463
77464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77465   int jresult ;
77466   int result;
77467
77468   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77469   jresult = (int)result;
77470   return jresult;
77471 }
77472
77473
77474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77475   int jresult ;
77476   int result;
77477
77478   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77479   jresult = (int)result;
77480   return jresult;
77481 }
77482
77483
77484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77485   int jresult ;
77486   int result;
77487
77488   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77489   jresult = (int)result;
77490   return jresult;
77491 }
77492
77493
77494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77495   int jresult ;
77496   int result;
77497
77498   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77499   jresult = (int)result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77505   int jresult ;
77506   int result;
77507
77508   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77509   jresult = (int)result;
77510   return jresult;
77511 }
77512
77513
77514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77515   int jresult ;
77516   int result;
77517
77518   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77519   jresult = (int)result;
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77525   int jresult ;
77526   int result;
77527
77528   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77529   jresult = (int)result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77535   int jresult ;
77536   int result;
77537
77538   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77539   jresult = (int)result;
77540   return jresult;
77541 }
77542
77543
77544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77545   int jresult ;
77546   int result;
77547
77548   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77549   jresult = (int)result;
77550   return jresult;
77551 }
77552
77553
77554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77555   int jresult ;
77556   int result;
77557
77558   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77559   jresult = (int)result;
77560   return jresult;
77561 }
77562
77563
77564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77565   int jresult ;
77566   int result;
77567
77568   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77569   jresult = (int)result;
77570   return jresult;
77571 }
77572
77573
77574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77575   int jresult ;
77576   int result;
77577
77578   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77579   jresult = (int)result;
77580   return jresult;
77581 }
77582
77583
77584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77585   int jresult ;
77586   int result;
77587
77588   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77589   jresult = (int)result;
77590   return jresult;
77591 }
77592
77593
77594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77595   int jresult ;
77596   int result;
77597
77598   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77599   jresult = (int)result;
77600   return jresult;
77601 }
77602
77603
77604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77605   int jresult ;
77606   int result;
77607
77608   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77609   jresult = (int)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77615   int jresult ;
77616   int result;
77617
77618   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77619   jresult = (int)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77625   int jresult ;
77626   int result;
77627
77628   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77629   jresult = (int)result;
77630   return jresult;
77631 }
77632
77633
77634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77635   int jresult ;
77636   int result;
77637
77638   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77639   jresult = (int)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77645   int jresult ;
77646   int result;
77647
77648   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77649   jresult = (int)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77655   int jresult ;
77656   int result;
77657
77658   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77659   jresult = (int)result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77665   int jresult ;
77666   int result;
77667
77668   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77669   jresult = (int)result;
77670   return jresult;
77671 }
77672
77673
77674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77675   int jresult ;
77676   int result;
77677
77678   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77685   int jresult ;
77686   int result;
77687
77688   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77689   jresult = (int)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77735   void * jresult ;
77736   Dali::Toolkit::TextField::Property *result = 0 ;
77737
77738   {
77739     try {
77740       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77741     } catch (std::out_of_range& e) {
77742       {
77743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77744       };
77745     } catch (std::exception& e) {
77746       {
77747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77748       };
77749     } catch (...) {
77750       {
77751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77752       };
77753     }
77754   }
77755   jresult = (void *)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77761   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77762
77763   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77764   {
77765     try {
77766       delete arg1;
77767     } catch (std::out_of_range& e) {
77768       {
77769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77770       };
77771     } catch (std::exception& e) {
77772       {
77773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77774       };
77775     } catch (...) {
77776       {
77777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77778       };
77779     }
77780   }
77781 }
77782
77783
77784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77785   void * jresult ;
77786   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77787
77788   {
77789     try {
77790       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77791     } catch (std::out_of_range& e) {
77792       {
77793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77794       };
77795     } catch (std::exception& e) {
77796       {
77797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77802       };
77803     }
77804   }
77805   jresult = (void *)result;
77806   return jresult;
77807 }
77808
77809
77810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77811   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77812
77813   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77814   {
77815     try {
77816       delete arg1;
77817     } catch (std::out_of_range& e) {
77818       {
77819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77820       };
77821     } catch (std::exception& e) {
77822       {
77823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77824       };
77825     } catch (...) {
77826       {
77827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77828       };
77829     }
77830   }
77831 }
77832
77833
77834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77835   void * jresult ;
77836   Dali::Toolkit::TextField result;
77837
77838   {
77839     try {
77840       result = Dali::Toolkit::TextField::New();
77841     } catch (std::out_of_range& e) {
77842       {
77843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77844       };
77845     } catch (std::exception& e) {
77846       {
77847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77848       };
77849     } catch (...) {
77850       {
77851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77852       };
77853     }
77854   }
77855   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77861   void * jresult ;
77862   Dali::Toolkit::TextField *result = 0 ;
77863
77864   {
77865     try {
77866       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77867     } catch (std::out_of_range& e) {
77868       {
77869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77870       };
77871     } catch (std::exception& e) {
77872       {
77873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77874       };
77875     } catch (...) {
77876       {
77877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77878       };
77879     }
77880   }
77881   jresult = (void *)result;
77882   return jresult;
77883 }
77884
77885
77886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77887   void * jresult ;
77888   Dali::Toolkit::TextField *arg1 = 0 ;
77889   Dali::Toolkit::TextField *result = 0 ;
77890
77891   arg1 = (Dali::Toolkit::TextField *)jarg1;
77892   if (!arg1) {
77893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77894     return 0;
77895   }
77896   {
77897     try {
77898       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77899     } catch (std::out_of_range& e) {
77900       {
77901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77902       };
77903     } catch (std::exception& e) {
77904       {
77905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77906       };
77907     } catch (...) {
77908       {
77909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77910       };
77911     }
77912   }
77913   jresult = (void *)result;
77914   return jresult;
77915 }
77916
77917
77918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77919   void * jresult ;
77920   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77921   Dali::Toolkit::TextField *arg2 = 0 ;
77922   Dali::Toolkit::TextField *result = 0 ;
77923
77924   arg1 = (Dali::Toolkit::TextField *)jarg1;
77925   arg2 = (Dali::Toolkit::TextField *)jarg2;
77926   if (!arg2) {
77927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77928     return 0;
77929   }
77930   {
77931     try {
77932       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77933     } catch (std::out_of_range& e) {
77934       {
77935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77936       };
77937     } catch (std::exception& e) {
77938       {
77939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77940       };
77941     } catch (...) {
77942       {
77943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77944       };
77945     }
77946   }
77947   jresult = (void *)result;
77948   return jresult;
77949 }
77950
77951
77952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77953   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77954
77955   arg1 = (Dali::Toolkit::TextField *)jarg1;
77956   {
77957     try {
77958       delete arg1;
77959     } catch (std::out_of_range& e) {
77960       {
77961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77962       };
77963     } catch (std::exception& e) {
77964       {
77965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77966       };
77967     } catch (...) {
77968       {
77969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77970       };
77971     }
77972   }
77973 }
77974
77975
77976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77977   void * jresult ;
77978   Dali::BaseHandle arg1 ;
77979   Dali::BaseHandle *argp1 ;
77980   Dali::Toolkit::TextField result;
77981
77982   argp1 = (Dali::BaseHandle *)jarg1;
77983   if (!argp1) {
77984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77985     return 0;
77986   }
77987   arg1 = *argp1;
77988   {
77989     try {
77990       result = Dali::Toolkit::TextField::DownCast(arg1);
77991     } catch (std::out_of_range& e) {
77992       {
77993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (std::exception& e) {
77996       {
77997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77998       };
77999     } catch (...) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78002       };
78003     }
78004   }
78005   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78006   return jresult;
78007 }
78008
78009
78010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78011   void * jresult ;
78012   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78013   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78014
78015   arg1 = (Dali::Toolkit::TextField *)jarg1;
78016   {
78017     try {
78018       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78019     } catch (std::out_of_range& e) {
78020       {
78021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78022       };
78023     } catch (std::exception& e) {
78024       {
78025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78026       };
78027     } catch (...) {
78028       {
78029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78030       };
78031     }
78032   }
78033   jresult = (void *)result;
78034   return jresult;
78035 }
78036
78037
78038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78039   void * jresult ;
78040   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78041   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78042
78043   arg1 = (Dali::Toolkit::TextField *)jarg1;
78044   {
78045     try {
78046       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78047     } catch (std::out_of_range& e) {
78048       {
78049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (std::exception& e) {
78052       {
78053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061   jresult = (void *)result;
78062   return jresult;
78063 }
78064
78065
78066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78067   void * jresult ;
78068   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78069   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78070
78071   arg1 = (Dali::Toolkit::TextField *)jarg1;
78072   {
78073     try {
78074       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78075     } catch (std::out_of_range& e) {
78076       {
78077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78078       };
78079     } catch (std::exception& e) {
78080       {
78081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78082       };
78083     } catch (...) {
78084       {
78085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78086       };
78087     }
78088   }
78089   jresult = (void *)result;
78090   return jresult;
78091 }
78092
78093
78094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78095   int jresult ;
78096   int result;
78097
78098   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78099   jresult = (int)result;
78100   return jresult;
78101 }
78102
78103
78104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78105   int jresult ;
78106   int result;
78107
78108   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78109   jresult = (int)result;
78110   return jresult;
78111 }
78112
78113
78114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78115   int jresult ;
78116   int result;
78117
78118   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78119   jresult = (int)result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78125   int jresult ;
78126   int result;
78127
78128   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78129   jresult = (int)result;
78130   return jresult;
78131 }
78132
78133
78134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78135   int jresult ;
78136   int result;
78137
78138   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78139   jresult = (int)result;
78140   return jresult;
78141 }
78142
78143
78144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78145   int jresult ;
78146   int result;
78147
78148   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78149   jresult = (int)result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78155   int jresult ;
78156   int result;
78157
78158   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78159   jresult = (int)result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78165   int jresult ;
78166   int result;
78167
78168   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78169   jresult = (int)result;
78170   return jresult;
78171 }
78172
78173
78174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78175   int jresult ;
78176   int result;
78177
78178   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78179   jresult = (int)result;
78180   return jresult;
78181 }
78182
78183
78184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78185   int jresult ;
78186   int result;
78187
78188   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78189   jresult = (int)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78195   int jresult ;
78196   int result;
78197
78198   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78199   jresult = (int)result;
78200   return jresult;
78201 }
78202
78203
78204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78205   int jresult ;
78206   int result;
78207
78208   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78209   jresult = (int)result;
78210   return jresult;
78211 }
78212
78213
78214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78215   int jresult ;
78216   int result;
78217
78218   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78219   jresult = (int)result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78225   int jresult ;
78226   int result;
78227
78228   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78229   jresult = (int)result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78235   int jresult ;
78236   int result;
78237
78238   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78239   jresult = (int)result;
78240   return jresult;
78241 }
78242
78243
78244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78245   int jresult ;
78246   int result;
78247
78248   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78249   jresult = (int)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78255   int jresult ;
78256   int result;
78257
78258   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78259   jresult = (int)result;
78260   return jresult;
78261 }
78262
78263
78264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78265   int jresult ;
78266   int result;
78267
78268   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78269   jresult = (int)result;
78270   return jresult;
78271 }
78272
78273
78274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78275   int jresult ;
78276   int result;
78277
78278   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78279   jresult = (int)result;
78280   return jresult;
78281 }
78282
78283
78284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78285   int jresult ;
78286   int result;
78287
78288   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78289   jresult = (int)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78295   int jresult ;
78296   int result;
78297
78298   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78299   jresult = (int)result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78305   int jresult ;
78306   int result;
78307
78308   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78309   jresult = (int)result;
78310   return jresult;
78311 }
78312
78313
78314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78315   int jresult ;
78316   int result;
78317
78318   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78319   jresult = (int)result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78325   int jresult ;
78326   int result;
78327
78328   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78329   jresult = (int)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78335   void * jresult ;
78336   Dali::Toolkit::TextLabel::Property *result = 0 ;
78337
78338   {
78339     try {
78340       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78341     } catch (std::out_of_range& e) {
78342       {
78343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78344       };
78345     } catch (std::exception& e) {
78346       {
78347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78348       };
78349     } catch (...) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78352       };
78353     }
78354   }
78355   jresult = (void *)result;
78356   return jresult;
78357 }
78358
78359
78360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78361   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78362
78363   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78364   {
78365     try {
78366       delete arg1;
78367     } catch (std::out_of_range& e) {
78368       {
78369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78370       };
78371     } catch (std::exception& e) {
78372       {
78373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78374       };
78375     } catch (...) {
78376       {
78377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78378       };
78379     }
78380   }
78381 }
78382
78383
78384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78385   void * jresult ;
78386   Dali::Toolkit::TextLabel result;
78387
78388   {
78389     try {
78390       result = Dali::Toolkit::TextLabel::New();
78391     } catch (std::out_of_range& e) {
78392       {
78393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78394       };
78395     } catch (std::exception& e) {
78396       {
78397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78398       };
78399     } catch (...) {
78400       {
78401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78402       };
78403     }
78404   }
78405   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78406   return jresult;
78407 }
78408
78409
78410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78411   void * jresult ;
78412   std::string *arg1 = 0 ;
78413   Dali::Toolkit::TextLabel result;
78414
78415   if (!jarg1) {
78416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78417     return 0;
78418   }
78419   std::string arg1_str(jarg1);
78420   arg1 = &arg1_str;
78421   {
78422     try {
78423       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78424     } catch (std::out_of_range& e) {
78425       {
78426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78427       };
78428     } catch (std::exception& e) {
78429       {
78430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78431       };
78432     } catch (...) {
78433       {
78434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78435       };
78436     }
78437   }
78438   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78439
78440   //argout typemap for const std::string&
78441
78442   return jresult;
78443 }
78444
78445
78446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78447   void * jresult ;
78448   Dali::Toolkit::TextLabel *result = 0 ;
78449
78450   {
78451     try {
78452       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78453     } catch (std::out_of_range& e) {
78454       {
78455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78456       };
78457     } catch (std::exception& e) {
78458       {
78459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78460       };
78461     } catch (...) {
78462       {
78463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78464       };
78465     }
78466   }
78467   jresult = (void *)result;
78468   return jresult;
78469 }
78470
78471
78472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78473   void * jresult ;
78474   Dali::Toolkit::TextLabel *arg1 = 0 ;
78475   Dali::Toolkit::TextLabel *result = 0 ;
78476
78477   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78478   if (!arg1) {
78479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78480     return 0;
78481   }
78482   {
78483     try {
78484       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78485     } catch (std::out_of_range& e) {
78486       {
78487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78488       };
78489     } catch (std::exception& e) {
78490       {
78491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78492       };
78493     } catch (...) {
78494       {
78495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78496       };
78497     }
78498   }
78499   jresult = (void *)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78505   void * jresult ;
78506   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78507   Dali::Toolkit::TextLabel *arg2 = 0 ;
78508   Dali::Toolkit::TextLabel *result = 0 ;
78509
78510   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78511   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78512   if (!arg2) {
78513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78514     return 0;
78515   }
78516   {
78517     try {
78518       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78519     } catch (std::out_of_range& e) {
78520       {
78521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78522       };
78523     } catch (std::exception& e) {
78524       {
78525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78526       };
78527     } catch (...) {
78528       {
78529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78530       };
78531     }
78532   }
78533   jresult = (void *)result;
78534   return jresult;
78535 }
78536
78537
78538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78539   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78540
78541   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78542   {
78543     try {
78544       delete arg1;
78545     } catch (std::out_of_range& e) {
78546       {
78547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78548       };
78549     } catch (std::exception& e) {
78550       {
78551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78552       };
78553     } catch (...) {
78554       {
78555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78556       };
78557     }
78558   }
78559 }
78560
78561
78562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78563   void * jresult ;
78564   Dali::BaseHandle arg1 ;
78565   Dali::BaseHandle *argp1 ;
78566   Dali::Toolkit::TextLabel result;
78567
78568   argp1 = (Dali::BaseHandle *)jarg1;
78569   if (!argp1) {
78570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78571     return 0;
78572   }
78573   arg1 = *argp1;
78574   {
78575     try {
78576       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78577     } catch (std::out_of_range& e) {
78578       {
78579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78580       };
78581     } catch (std::exception& e) {
78582       {
78583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78584       };
78585     } catch (...) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78588       };
78589     }
78590   }
78591   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78597   void * jresult ;
78598   Dali::Toolkit::AccessibilityManager *result = 0 ;
78599
78600   {
78601     try {
78602       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78603     } catch (std::out_of_range& e) {
78604       {
78605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78606       };
78607     } catch (std::exception& e) {
78608       {
78609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78610       };
78611     } catch (...) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78614       };
78615     }
78616   }
78617   jresult = (void *)result;
78618   return jresult;
78619 }
78620
78621
78622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78624
78625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78626   {
78627     try {
78628       delete arg1;
78629     } catch (std::out_of_range& e) {
78630       {
78631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78632       };
78633     } catch (std::exception& e) {
78634       {
78635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78636       };
78637     } catch (...) {
78638       {
78639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78640       };
78641     }
78642   }
78643 }
78644
78645
78646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78647   void * jresult ;
78648   Dali::Toolkit::AccessibilityManager result;
78649
78650   {
78651     try {
78652       result = Dali::Toolkit::AccessibilityManager::Get();
78653     } catch (std::out_of_range& e) {
78654       {
78655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78656       };
78657     } catch (std::exception& e) {
78658       {
78659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78660       };
78661     } catch (...) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78664       };
78665     }
78666   }
78667   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78668   return jresult;
78669 }
78670
78671
78672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78674   Dali::Actor arg2 ;
78675   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78676   std::string *arg4 = 0 ;
78677   Dali::Actor *argp2 ;
78678
78679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78680   argp2 = (Dali::Actor *)jarg2;
78681   if (!argp2) {
78682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78683     return ;
78684   }
78685   arg2 = *argp2;
78686   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78687   if (!jarg4) {
78688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78689     return ;
78690   }
78691   std::string arg4_str(jarg4);
78692   arg4 = &arg4_str;
78693   {
78694     try {
78695       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78696     } catch (std::out_of_range& e) {
78697       {
78698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78699       };
78700     } catch (std::exception& e) {
78701       {
78702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78703       };
78704     } catch (...) {
78705       {
78706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78707       };
78708     }
78709   }
78710
78711   //argout typemap for const std::string&
78712
78713 }
78714
78715
78716 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78717   char * jresult ;
78718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78719   Dali::Actor arg2 ;
78720   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78721   Dali::Actor *argp2 ;
78722   std::string result;
78723
78724   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78725   argp2 = (Dali::Actor *)jarg2;
78726   if (!argp2) {
78727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78728     return 0;
78729   }
78730   arg2 = *argp2;
78731   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78732   {
78733     try {
78734       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78735     } catch (std::out_of_range& e) {
78736       {
78737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78738       };
78739     } catch (std::exception& e) {
78740       {
78741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78742       };
78743     } catch (...) {
78744       {
78745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78746       };
78747     }
78748   }
78749   jresult = SWIG_csharp_string_callback((&result)->c_str());
78750   return jresult;
78751 }
78752
78753
78754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78756   Dali::Actor arg2 ;
78757   unsigned int arg3 ;
78758   Dali::Actor *argp2 ;
78759
78760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78761   argp2 = (Dali::Actor *)jarg2;
78762   if (!argp2) {
78763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78764     return ;
78765   }
78766   arg2 = *argp2;
78767   arg3 = (unsigned int)jarg3;
78768   {
78769     try {
78770       (arg1)->SetFocusOrder(arg2,arg3);
78771     } catch (std::out_of_range& e) {
78772       {
78773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78774       };
78775     } catch (std::exception& e) {
78776       {
78777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78778       };
78779     } catch (...) {
78780       {
78781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78782       };
78783     }
78784   }
78785 }
78786
78787
78788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78789   unsigned int jresult ;
78790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78791   Dali::Actor arg2 ;
78792   Dali::Actor *argp2 ;
78793   unsigned int result;
78794
78795   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78796   argp2 = (Dali::Actor *)jarg2;
78797   if (!argp2) {
78798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78799     return 0;
78800   }
78801   arg2 = *argp2;
78802   {
78803     try {
78804       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78805     } catch (std::out_of_range& e) {
78806       {
78807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78808       };
78809     } catch (std::exception& e) {
78810       {
78811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78812       };
78813     } catch (...) {
78814       {
78815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78816       };
78817     }
78818   }
78819   jresult = result;
78820   return jresult;
78821 }
78822
78823
78824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78825   unsigned int jresult ;
78826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78827   unsigned int result;
78828
78829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78830   {
78831     try {
78832       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78833     } catch (std::out_of_range& e) {
78834       {
78835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78836       };
78837     } catch (std::exception& e) {
78838       {
78839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78840       };
78841     } catch (...) {
78842       {
78843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78844       };
78845     }
78846   }
78847   jresult = result;
78848   return jresult;
78849 }
78850
78851
78852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78853   void * jresult ;
78854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78855   unsigned int arg2 ;
78856   Dali::Actor result;
78857
78858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78859   arg2 = (unsigned int)jarg2;
78860   {
78861     try {
78862       result = (arg1)->GetActorByFocusOrder(arg2);
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (...) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78874       };
78875     }
78876   }
78877   jresult = new Dali::Actor((const Dali::Actor &)result);
78878   return jresult;
78879 }
78880
78881
78882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78883   unsigned int jresult ;
78884   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78885   Dali::Actor arg2 ;
78886   Dali::Actor *argp2 ;
78887   bool result;
78888
78889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78890   argp2 = (Dali::Actor *)jarg2;
78891   if (!argp2) {
78892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78893     return 0;
78894   }
78895   arg2 = *argp2;
78896   {
78897     try {
78898       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78899     } catch (std::out_of_range& e) {
78900       {
78901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78902       };
78903     } catch (std::exception& e) {
78904       {
78905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78906       };
78907     } catch (...) {
78908       {
78909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78910       };
78911     }
78912   }
78913   jresult = result;
78914   return jresult;
78915 }
78916
78917
78918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78919   void * jresult ;
78920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78921   Dali::Actor result;
78922
78923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78924   {
78925     try {
78926       result = (arg1)->GetCurrentFocusActor();
78927     } catch (std::out_of_range& e) {
78928       {
78929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78930       };
78931     } catch (std::exception& e) {
78932       {
78933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (...) {
78936       {
78937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78938       };
78939     }
78940   }
78941   jresult = new Dali::Actor((const Dali::Actor &)result);
78942   return jresult;
78943 }
78944
78945
78946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78947   void * jresult ;
78948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78949   Dali::Actor result;
78950
78951   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78952   {
78953     try {
78954       result = (arg1)->GetCurrentFocusGroup();
78955     } catch (std::out_of_range& e) {
78956       {
78957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78958       };
78959     } catch (std::exception& e) {
78960       {
78961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78962       };
78963     } catch (...) {
78964       {
78965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78966       };
78967     }
78968   }
78969   jresult = new Dali::Actor((const Dali::Actor &)result);
78970   return jresult;
78971 }
78972
78973
78974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78975   unsigned int jresult ;
78976   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78977   unsigned int result;
78978
78979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78980   {
78981     try {
78982       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78983     } catch (std::out_of_range& e) {
78984       {
78985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78986       };
78987     } catch (std::exception& e) {
78988       {
78989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78990       };
78991     } catch (...) {
78992       {
78993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78994       };
78995     }
78996   }
78997   jresult = result;
78998   return jresult;
78999 }
79000
79001
79002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79003   unsigned int jresult ;
79004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79005   bool result;
79006
79007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79008   {
79009     try {
79010       result = (bool)(arg1)->MoveFocusForward();
79011     } catch (std::out_of_range& e) {
79012       {
79013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79014       };
79015     } catch (std::exception& e) {
79016       {
79017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79018       };
79019     } catch (...) {
79020       {
79021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79022       };
79023     }
79024   }
79025   jresult = result;
79026   return jresult;
79027 }
79028
79029
79030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79031   unsigned int jresult ;
79032   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79033   bool result;
79034
79035   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79036   {
79037     try {
79038       result = (bool)(arg1)->MoveFocusBackward();
79039     } catch (std::out_of_range& e) {
79040       {
79041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79042       };
79043     } catch (std::exception& e) {
79044       {
79045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79046       };
79047     } catch (...) {
79048       {
79049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79050       };
79051     }
79052   }
79053   jresult = result;
79054   return jresult;
79055 }
79056
79057
79058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79060
79061   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79062   {
79063     try {
79064       (arg1)->ClearFocus();
79065     } catch (std::out_of_range& e) {
79066       {
79067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79068       };
79069     } catch (std::exception& e) {
79070       {
79071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79072       };
79073     } catch (...) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79076       };
79077     }
79078   }
79079 }
79080
79081
79082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79084
79085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79086   {
79087     try {
79088       (arg1)->Reset();
79089     } catch (std::out_of_range& e) {
79090       {
79091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79092       };
79093     } catch (std::exception& e) {
79094       {
79095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79096       };
79097     } catch (...) {
79098       {
79099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79100       };
79101     }
79102   }
79103 }
79104
79105
79106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79108   Dali::Actor arg2 ;
79109   bool arg3 ;
79110   Dali::Actor *argp2 ;
79111
79112   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79113   argp2 = (Dali::Actor *)jarg2;
79114   if (!argp2) {
79115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79116     return ;
79117   }
79118   arg2 = *argp2;
79119   arg3 = jarg3 ? true : false;
79120   {
79121     try {
79122       (arg1)->SetFocusGroup(arg2,arg3);
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79130       };
79131     } catch (...) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79134       };
79135     }
79136   }
79137 }
79138
79139
79140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79141   unsigned int jresult ;
79142   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79143   Dali::Actor arg2 ;
79144   Dali::Actor *argp2 ;
79145   bool result;
79146
79147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79148   argp2 = (Dali::Actor *)jarg2;
79149   if (!argp2) {
79150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79151     return 0;
79152   }
79153   arg2 = *argp2;
79154   {
79155     try {
79156       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79168       };
79169     }
79170   }
79171   jresult = result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79178   bool arg2 ;
79179
79180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79181   arg2 = jarg2 ? true : false;
79182   {
79183     try {
79184       (arg1)->SetGroupMode(arg2);
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79192       };
79193     } catch (...) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79196       };
79197     }
79198   }
79199 }
79200
79201
79202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79203   unsigned int jresult ;
79204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79205   bool result;
79206
79207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79208   {
79209     try {
79210       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79211     } catch (std::out_of_range& e) {
79212       {
79213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79214       };
79215     } catch (std::exception& e) {
79216       {
79217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79218       };
79219     } catch (...) {
79220       {
79221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79222       };
79223     }
79224   }
79225   jresult = result;
79226   return jresult;
79227 }
79228
79229
79230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79231   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79232   bool arg2 ;
79233
79234   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79235   arg2 = jarg2 ? true : false;
79236   {
79237     try {
79238       (arg1)->SetWrapMode(arg2);
79239     } catch (std::out_of_range& e) {
79240       {
79241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79242       };
79243     } catch (std::exception& e) {
79244       {
79245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79246       };
79247     } catch (...) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79250       };
79251     }
79252   }
79253 }
79254
79255
79256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79257   unsigned int jresult ;
79258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79259   bool result;
79260
79261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79262   {
79263     try {
79264       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79265     } catch (std::out_of_range& e) {
79266       {
79267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79268       };
79269     } catch (std::exception& e) {
79270       {
79271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79272       };
79273     } catch (...) {
79274       {
79275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79276       };
79277     }
79278   }
79279   jresult = result;
79280   return jresult;
79281 }
79282
79283
79284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79285   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79286   Dali::Actor arg2 ;
79287   Dali::Actor *argp2 ;
79288
79289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79290   argp2 = (Dali::Actor *)jarg2;
79291   if (!argp2) {
79292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79293     return ;
79294   }
79295   arg2 = *argp2;
79296   {
79297     try {
79298       (arg1)->SetFocusIndicatorActor(arg2);
79299     } catch (std::out_of_range& e) {
79300       {
79301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79302       };
79303     } catch (std::exception& e) {
79304       {
79305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79306       };
79307     } catch (...) {
79308       {
79309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79310       };
79311     }
79312   }
79313 }
79314
79315
79316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79317   void * jresult ;
79318   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79319   Dali::Actor result;
79320
79321   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79322   {
79323     try {
79324       result = (arg1)->GetFocusIndicatorActor();
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79332       };
79333     } catch (...) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79336       };
79337     }
79338   }
79339   jresult = new Dali::Actor((const Dali::Actor &)result);
79340   return jresult;
79341 }
79342
79343
79344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79345   void * jresult ;
79346   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79347   Dali::Actor arg2 ;
79348   Dali::Actor *argp2 ;
79349   Dali::Actor result;
79350
79351   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79352   argp2 = (Dali::Actor *)jarg2;
79353   if (!argp2) {
79354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79355     return 0;
79356   }
79357   arg2 = *argp2;
79358   {
79359     try {
79360       result = (arg1)->GetFocusGroup(arg2);
79361     } catch (std::out_of_range& e) {
79362       {
79363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79364       };
79365     } catch (std::exception& e) {
79366       {
79367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79368       };
79369     } catch (...) {
79370       {
79371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79372       };
79373     }
79374   }
79375   jresult = new Dali::Actor((const Dali::Actor &)result);
79376   return jresult;
79377 }
79378
79379
79380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79381   void * jresult ;
79382   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79383   Dali::Vector2 result;
79384
79385   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79386   {
79387     try {
79388       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79389     } catch (std::out_of_range& e) {
79390       {
79391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79392       };
79393     } catch (std::exception& e) {
79394       {
79395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79396       };
79397     } catch (...) {
79398       {
79399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79400       };
79401     }
79402   }
79403   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79404   return jresult;
79405 }
79406
79407
79408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79409   void * jresult ;
79410   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79411   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79412
79413   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79414   {
79415     try {
79416       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79417     } catch (std::out_of_range& e) {
79418       {
79419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79420       };
79421     } catch (std::exception& e) {
79422       {
79423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79424       };
79425     } catch (...) {
79426       {
79427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79428       };
79429     }
79430   }
79431   jresult = (void *)result;
79432   return jresult;
79433 }
79434
79435
79436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79437   void * jresult ;
79438   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79439   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79440
79441   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79442   {
79443     try {
79444       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79445     } catch (std::out_of_range& e) {
79446       {
79447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79448       };
79449     } catch (std::exception& e) {
79450       {
79451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79452       };
79453     } catch (...) {
79454       {
79455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79456       };
79457     }
79458   }
79459   jresult = (void *)result;
79460   return jresult;
79461 }
79462
79463
79464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79465   void * jresult ;
79466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79467   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79468
79469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79470   {
79471     try {
79472       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79473     } catch (std::out_of_range& e) {
79474       {
79475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79476       };
79477     } catch (std::exception& e) {
79478       {
79479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79480       };
79481     } catch (...) {
79482       {
79483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79484       };
79485     }
79486   }
79487   jresult = (void *)result;
79488   return jresult;
79489 }
79490
79491
79492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79493   void * jresult ;
79494   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79495   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79496
79497   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79498   {
79499     try {
79500       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515   jresult = (void *)result;
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79521   void * jresult ;
79522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79523   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79524
79525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79526   {
79527     try {
79528       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79529     } catch (std::out_of_range& e) {
79530       {
79531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (std::exception& e) {
79534       {
79535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (...) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79540       };
79541     }
79542   }
79543   jresult = (void *)result;
79544   return jresult;
79545 }
79546
79547
79548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79549   void * jresult ;
79550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79551   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79552
79553   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79554   {
79555     try {
79556       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79557     } catch (std::out_of_range& e) {
79558       {
79559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79560       };
79561     } catch (std::exception& e) {
79562       {
79563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79564       };
79565     } catch (...) {
79566       {
79567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79568       };
79569     }
79570   }
79571   jresult = (void *)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79577   void * jresult ;
79578   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79579   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79580
79581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79582   {
79583     try {
79584       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79585     } catch (std::out_of_range& e) {
79586       {
79587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79588       };
79589     } catch (std::exception& e) {
79590       {
79591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79592       };
79593     } catch (...) {
79594       {
79595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79596       };
79597     }
79598   }
79599   jresult = (void *)result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79605   void * jresult ;
79606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79607   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79608
79609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79610   {
79611     try {
79612       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (...) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79624       };
79625     }
79626   }
79627   jresult = (void *)result;
79628   return jresult;
79629 }
79630
79631
79632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79633   void * jresult ;
79634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79635   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79636
79637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79638   {
79639     try {
79640       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (...) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79652       };
79653     }
79654   }
79655   jresult = (void *)result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79661   void * jresult ;
79662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79663   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79664
79665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79666   {
79667     try {
79668       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (...) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79680       };
79681     }
79682   }
79683   jresult = (void *)result;
79684   return jresult;
79685 }
79686
79687
79688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79689   void * jresult ;
79690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79691   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79692
79693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79694   {
79695     try {
79696       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79697     } catch (std::out_of_range& e) {
79698       {
79699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79700       };
79701     } catch (std::exception& e) {
79702       {
79703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (...) {
79706       {
79707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79708       };
79709     }
79710   }
79711   jresult = (void *)result;
79712   return jresult;
79713 }
79714
79715
79716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79717   void * jresult ;
79718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79720
79721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79722   {
79723     try {
79724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79725     } catch (std::out_of_range& e) {
79726       {
79727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79728       };
79729     } catch (std::exception& e) {
79730       {
79731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (...) {
79734       {
79735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79736       };
79737     }
79738   }
79739   jresult = (void *)result;
79740   return jresult;
79741 }
79742
79743
79744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79745   void * jresult ;
79746   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79747   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79748
79749   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79750   {
79751     try {
79752       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79753     } catch (std::out_of_range& e) {
79754       {
79755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79756       };
79757     } catch (std::exception& e) {
79758       {
79759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79760       };
79761     } catch (...) {
79762       {
79763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79764       };
79765     }
79766   }
79767   jresult = (void *)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79773   void * jresult ;
79774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79775   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79776
79777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79778   {
79779     try {
79780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79792       };
79793     }
79794   }
79795   jresult = (void *)result;
79796   return jresult;
79797 }
79798
79799
79800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79801   void * jresult ;
79802   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79803   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79804
79805   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79806   {
79807     try {
79808       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (...) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79820       };
79821     }
79822   }
79823   jresult = (void *)result;
79824   return jresult;
79825 }
79826
79827
79828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79829   void * jresult ;
79830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79831   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79832
79833   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79834   {
79835     try {
79836       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79844       };
79845     } catch (...) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79848       };
79849     }
79850   }
79851   jresult = (void *)result;
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79857   void * jresult ;
79858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79859   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79860
79861   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79862   {
79863     try {
79864       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79865     } catch (std::out_of_range& e) {
79866       {
79867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79868       };
79869     } catch (std::exception& e) {
79870       {
79871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79872       };
79873     } catch (...) {
79874       {
79875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79876       };
79877     }
79878   }
79879   jresult = (void *)result;
79880   return jresult;
79881 }
79882
79883
79884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79885   void * jresult ;
79886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79887   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79888
79889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79890   {
79891     try {
79892       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79893     } catch (std::out_of_range& e) {
79894       {
79895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79896       };
79897     } catch (std::exception& e) {
79898       {
79899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79900       };
79901     } catch (...) {
79902       {
79903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79904       };
79905     }
79906   }
79907   jresult = (void *)result;
79908   return jresult;
79909 }
79910
79911
79912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79913   void * jresult ;
79914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79915   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79916
79917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79918   {
79919     try {
79920       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79921     } catch (std::out_of_range& e) {
79922       {
79923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79924       };
79925     } catch (std::exception& e) {
79926       {
79927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79928       };
79929     } catch (...) {
79930       {
79931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79932       };
79933     }
79934   }
79935   jresult = (void *)result;
79936   return jresult;
79937 }
79938
79939
79940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79941   void * jresult ;
79942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79944
79945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79946   {
79947     try {
79948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79949     } catch (std::out_of_range& e) {
79950       {
79951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79952       };
79953     } catch (std::exception& e) {
79954       {
79955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79956       };
79957     } catch (...) {
79958       {
79959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79960       };
79961     }
79962   }
79963   jresult = (void *)result;
79964   return jresult;
79965 }
79966
79967
79968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79969   void * jresult ;
79970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79971   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79972
79973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79974   {
79975     try {
79976       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79977     } catch (std::out_of_range& e) {
79978       {
79979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79980       };
79981     } catch (std::exception& e) {
79982       {
79983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (...) {
79986       {
79987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79988       };
79989     }
79990   }
79991   jresult = (void *)result;
79992   return jresult;
79993 }
79994
79995
79996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
79997   void * jresult ;
79998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80000
80001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80002   {
80003     try {
80004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (...) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80016       };
80017     }
80018   }
80019   jresult = (void *)result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80025   void * jresult ;
80026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80028
80029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80030   {
80031     try {
80032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80033     } catch (std::out_of_range& e) {
80034       {
80035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80036       };
80037     } catch (std::exception& e) {
80038       {
80039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80040       };
80041     } catch (...) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80044       };
80045     }
80046   }
80047   jresult = (void *)result;
80048   return jresult;
80049 }
80050
80051
80052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80053   void * jresult ;
80054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80055   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80056
80057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80058   {
80059     try {
80060       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80061     } catch (std::out_of_range& e) {
80062       {
80063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80064       };
80065     } catch (std::exception& e) {
80066       {
80067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80072       };
80073     }
80074   }
80075   jresult = (void *)result;
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80081   void * jresult ;
80082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80083   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80084
80085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80086   {
80087     try {
80088       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80089     } catch (std::out_of_range& e) {
80090       {
80091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80092       };
80093     } catch (std::exception& e) {
80094       {
80095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80096       };
80097     } catch (...) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80100       };
80101     }
80102   }
80103   jresult = (void *)result;
80104   return jresult;
80105 }
80106
80107
80108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80109   void * jresult ;
80110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80111   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80112
80113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80114   {
80115     try {
80116       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80117     } catch (std::out_of_range& e) {
80118       {
80119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (std::exception& e) {
80122       {
80123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (...) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80128       };
80129     }
80130   }
80131   jresult = (void *)result;
80132   return jresult;
80133 }
80134
80135
80136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80137   void * jresult ;
80138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80140
80141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80142   {
80143     try {
80144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80145     } catch (std::out_of_range& e) {
80146       {
80147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80148       };
80149     } catch (std::exception& e) {
80150       {
80151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80152       };
80153     } catch (...) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80156       };
80157     }
80158   }
80159   jresult = (void *)result;
80160   return jresult;
80161 }
80162
80163
80164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80165   void * jresult ;
80166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80167   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80168
80169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80170   {
80171     try {
80172       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80184       };
80185     }
80186   }
80187   jresult = (void *)result;
80188   return jresult;
80189 }
80190
80191
80192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80193   void * jresult ;
80194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80195   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80196
80197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80198   {
80199     try {
80200       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80201     } catch (std::out_of_range& e) {
80202       {
80203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (std::exception& e) {
80206       {
80207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80208       };
80209     } catch (...) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80212       };
80213     }
80214   }
80215   jresult = (void *)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80221   void * jresult ;
80222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80223   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80224
80225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80226   {
80227     try {
80228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (...) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80240       };
80241     }
80242   }
80243   jresult = (void *)result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80249   void * jresult ;
80250   Dali::Toolkit::StyleManager *result = 0 ;
80251
80252   {
80253     try {
80254       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80255     } catch (std::out_of_range& e) {
80256       {
80257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80258       };
80259     } catch (std::exception& e) {
80260       {
80261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80262       };
80263     } catch (...) {
80264       {
80265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80266       };
80267     }
80268   }
80269   jresult = (void *)result;
80270   return jresult;
80271 }
80272
80273
80274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80275   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80276
80277   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80278   {
80279     try {
80280       delete arg1;
80281     } catch (std::out_of_range& e) {
80282       {
80283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80284       };
80285     } catch (std::exception& e) {
80286       {
80287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80288       };
80289     } catch (...) {
80290       {
80291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80292       };
80293     }
80294   }
80295 }
80296
80297
80298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80299   void * jresult ;
80300   Dali::Toolkit::StyleManager result;
80301
80302   {
80303     try {
80304       result = Dali::Toolkit::StyleManager::Get();
80305     } catch (std::out_of_range& e) {
80306       {
80307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (std::exception& e) {
80310       {
80311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (...) {
80314       {
80315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80316       };
80317     }
80318   }
80319   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80325   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80326   std::string *arg2 = 0 ;
80327
80328   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80329   if (!jarg2) {
80330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80331     return ;
80332   }
80333   std::string arg2_str(jarg2);
80334   arg2 = &arg2_str;
80335   {
80336     try {
80337       (arg1)->ApplyTheme((std::string const &)*arg2);
80338     } catch (std::out_of_range& e) {
80339       {
80340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80341       };
80342     } catch (std::exception& e) {
80343       {
80344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80345       };
80346     } catch (...) {
80347       {
80348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80349       };
80350     }
80351   }
80352
80353   //argout typemap for const std::string&
80354
80355 }
80356
80357
80358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80359   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80360
80361   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80362   {
80363     try {
80364       (arg1)->ApplyDefaultTheme();
80365     } catch (std::out_of_range& e) {
80366       {
80367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80368       };
80369     } catch (std::exception& e) {
80370       {
80371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80372       };
80373     } catch (...) {
80374       {
80375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80376       };
80377     }
80378   }
80379 }
80380
80381
80382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80383   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80384   std::string *arg2 = 0 ;
80385   Dali::Property::Value *arg3 = 0 ;
80386
80387   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80388   if (!jarg2) {
80389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80390     return ;
80391   }
80392   std::string arg2_str(jarg2);
80393   arg2 = &arg2_str;
80394   arg3 = (Dali::Property::Value *)jarg3;
80395   if (!arg3) {
80396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80397     return ;
80398   }
80399   {
80400     try {
80401       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80402     } catch (std::out_of_range& e) {
80403       {
80404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80405       };
80406     } catch (std::exception& e) {
80407       {
80408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80409       };
80410     } catch (...) {
80411       {
80412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80413       };
80414     }
80415   }
80416
80417   //argout typemap for const std::string&
80418
80419 }
80420
80421
80422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80423   unsigned int jresult ;
80424   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80425   std::string *arg2 = 0 ;
80426   Dali::Property::Value *arg3 = 0 ;
80427   bool result;
80428
80429   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80430   if (!jarg2) {
80431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80432     return 0;
80433   }
80434   std::string arg2_str(jarg2);
80435   arg2 = &arg2_str;
80436   arg3 = (Dali::Property::Value *)jarg3;
80437   if (!arg3) {
80438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80439     return 0;
80440   }
80441   {
80442     try {
80443       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80444     } catch (std::out_of_range& e) {
80445       {
80446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (std::exception& e) {
80449       {
80450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80451       };
80452     } catch (...) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80455       };
80456     }
80457   }
80458   jresult = result;
80459
80460   //argout typemap for const std::string&
80461
80462   return jresult;
80463 }
80464
80465
80466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80467   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80468   Dali::Toolkit::Control arg2 ;
80469   std::string *arg3 = 0 ;
80470   std::string *arg4 = 0 ;
80471   Dali::Toolkit::Control *argp2 ;
80472
80473   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80474   argp2 = (Dali::Toolkit::Control *)jarg2;
80475   if (!argp2) {
80476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80477     return ;
80478   }
80479   arg2 = *argp2;
80480   if (!jarg3) {
80481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80482     return ;
80483   }
80484   std::string arg3_str(jarg3);
80485   arg3 = &arg3_str;
80486   if (!jarg4) {
80487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80488     return ;
80489   }
80490   std::string arg4_str(jarg4);
80491   arg4 = &arg4_str;
80492   {
80493     try {
80494       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80495     } catch (std::out_of_range& e) {
80496       {
80497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80498       };
80499     } catch (std::exception& e) {
80500       {
80501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80502       };
80503     } catch (...) {
80504       {
80505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80506       };
80507     }
80508   }
80509
80510   //argout typemap for const std::string&
80511
80512
80513   //argout typemap for const std::string&
80514
80515 }
80516
80517
80518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80519   void * jresult ;
80520   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80521   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80522
80523   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80524   {
80525     try {
80526       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80527     } catch (std::out_of_range& e) {
80528       {
80529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80530       };
80531     } catch (std::exception& e) {
80532       {
80533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80538       };
80539     }
80540   }
80541   jresult = (void *)result;
80542   return jresult;
80543 }
80544
80545
80546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80547   int jresult ;
80548   int result;
80549
80550   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80551   jresult = (int)result;
80552   return jresult;
80553 }
80554
80555
80556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80557   int jresult ;
80558   int result;
80559
80560   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80561   jresult = (int)result;
80562   return jresult;
80563 }
80564
80565
80566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80567   int jresult ;
80568   int result;
80569
80570   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80571   jresult = (int)result;
80572   return jresult;
80573 }
80574
80575
80576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80577   int jresult ;
80578   int result;
80579
80580   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80581   jresult = (int)result;
80582   return jresult;
80583 }
80584
80585
80586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80587   int jresult ;
80588   int result;
80589
80590   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80591   jresult = (int)result;
80592   return jresult;
80593 }
80594
80595
80596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80597   int jresult ;
80598   int result;
80599
80600   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80601   jresult = (int)result;
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80607   int jresult ;
80608   int result;
80609
80610   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80611   jresult = (int)result;
80612   return jresult;
80613 }
80614
80615
80616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80617   int jresult ;
80618   int result;
80619
80620   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80621   jresult = (int)result;
80622   return jresult;
80623 }
80624
80625
80626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80627   int jresult ;
80628   int result;
80629
80630   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80631   jresult = (int)result;
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80637   int jresult ;
80638   int result;
80639
80640   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80641   jresult = (int)result;
80642   return jresult;
80643 }
80644
80645
80646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80647   int jresult ;
80648   int result;
80649
80650   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80651   jresult = (int)result;
80652   return jresult;
80653 }
80654
80655
80656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80657   int jresult ;
80658   int result;
80659
80660   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80661   jresult = (int)result;
80662   return jresult;
80663 }
80664
80665
80666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80667   int jresult ;
80668   int result;
80669
80670   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80671   jresult = (int)result;
80672   return jresult;
80673 }
80674
80675
80676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80677   int jresult ;
80678   int result;
80679
80680   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80681   jresult = (int)result;
80682   return jresult;
80683 }
80684
80685
80686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80687   int jresult ;
80688   int result;
80689
80690   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80691   jresult = (int)result;
80692   return jresult;
80693 }
80694
80695
80696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80697   void * jresult ;
80698   Dali::Toolkit::Slider::Property *result = 0 ;
80699
80700   {
80701     try {
80702       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80703     } catch (std::out_of_range& e) {
80704       {
80705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80706       };
80707     } catch (std::exception& e) {
80708       {
80709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80710       };
80711     } catch (...) {
80712       {
80713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80714       };
80715     }
80716   }
80717   jresult = (void *)result;
80718   return jresult;
80719 }
80720
80721
80722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80723   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80724
80725   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80726   {
80727     try {
80728       delete arg1;
80729     } catch (std::out_of_range& e) {
80730       {
80731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80732       };
80733     } catch (std::exception& e) {
80734       {
80735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80736       };
80737     } catch (...) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80740       };
80741     }
80742   }
80743 }
80744
80745
80746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80747   void * jresult ;
80748   Dali::Toolkit::Slider result;
80749
80750   {
80751     try {
80752       result = Dali::Toolkit::Slider::New();
80753     } catch (std::out_of_range& e) {
80754       {
80755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (std::exception& e) {
80758       {
80759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80764       };
80765     }
80766   }
80767   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80768   return jresult;
80769 }
80770
80771
80772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80773   void * jresult ;
80774   Dali::Toolkit::Slider *result = 0 ;
80775
80776   {
80777     try {
80778       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80779     } catch (std::out_of_range& e) {
80780       {
80781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80782       };
80783     } catch (std::exception& e) {
80784       {
80785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80786       };
80787     } catch (...) {
80788       {
80789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80790       };
80791     }
80792   }
80793   jresult = (void *)result;
80794   return jresult;
80795 }
80796
80797
80798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80799   void * jresult ;
80800   Dali::Toolkit::Slider *arg1 = 0 ;
80801   Dali::Toolkit::Slider *result = 0 ;
80802
80803   arg1 = (Dali::Toolkit::Slider *)jarg1;
80804   if (!arg1) {
80805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80806     return 0;
80807   }
80808   {
80809     try {
80810       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80811     } catch (std::out_of_range& e) {
80812       {
80813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80814       };
80815     } catch (std::exception& e) {
80816       {
80817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80818       };
80819     } catch (...) {
80820       {
80821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80822       };
80823     }
80824   }
80825   jresult = (void *)result;
80826   return jresult;
80827 }
80828
80829
80830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80831   void * jresult ;
80832   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80833   Dali::Toolkit::Slider *arg2 = 0 ;
80834   Dali::Toolkit::Slider *result = 0 ;
80835
80836   arg1 = (Dali::Toolkit::Slider *)jarg1;
80837   arg2 = (Dali::Toolkit::Slider *)jarg2;
80838   if (!arg2) {
80839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80840     return 0;
80841   }
80842   {
80843     try {
80844       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80845     } catch (std::out_of_range& e) {
80846       {
80847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80848       };
80849     } catch (std::exception& e) {
80850       {
80851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80852       };
80853     } catch (...) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80856       };
80857     }
80858   }
80859   jresult = (void *)result;
80860   return jresult;
80861 }
80862
80863
80864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80865   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80866
80867   arg1 = (Dali::Toolkit::Slider *)jarg1;
80868   {
80869     try {
80870       delete arg1;
80871     } catch (std::out_of_range& e) {
80872       {
80873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80874       };
80875     } catch (std::exception& e) {
80876       {
80877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80878       };
80879     } catch (...) {
80880       {
80881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80882       };
80883     }
80884   }
80885 }
80886
80887
80888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80889   void * jresult ;
80890   Dali::BaseHandle arg1 ;
80891   Dali::BaseHandle *argp1 ;
80892   Dali::Toolkit::Slider result;
80893
80894   argp1 = (Dali::BaseHandle *)jarg1;
80895   if (!argp1) {
80896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80897     return 0;
80898   }
80899   arg1 = *argp1;
80900   {
80901     try {
80902       result = Dali::Toolkit::Slider::DownCast(arg1);
80903     } catch (std::out_of_range& e) {
80904       {
80905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80906       };
80907     } catch (std::exception& e) {
80908       {
80909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80910       };
80911     } catch (...) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80914       };
80915     }
80916   }
80917   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80918   return jresult;
80919 }
80920
80921
80922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80923   void * jresult ;
80924   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80925   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80926
80927   arg1 = (Dali::Toolkit::Slider *)jarg1;
80928   {
80929     try {
80930       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80931     } catch (std::out_of_range& e) {
80932       {
80933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80934       };
80935     } catch (std::exception& e) {
80936       {
80937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80938       };
80939     } catch (...) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80942       };
80943     }
80944   }
80945   jresult = (void *)result;
80946   return jresult;
80947 }
80948
80949
80950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80951   void * jresult ;
80952   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80953   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80954
80955   arg1 = (Dali::Toolkit::Slider *)jarg1;
80956   {
80957     try {
80958       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80959     } catch (std::out_of_range& e) {
80960       {
80961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80962       };
80963     } catch (std::exception& e) {
80964       {
80965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80966       };
80967     } catch (...) {
80968       {
80969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80970       };
80971     }
80972   }
80973   jresult = (void *)result;
80974   return jresult;
80975 }
80976
80977
80978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80979   void * jresult ;
80980   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80981   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80982
80983   arg1 = (Dali::Toolkit::Slider *)jarg1;
80984   {
80985     try {
80986       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80987     } catch (std::out_of_range& e) {
80988       {
80989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80990       };
80991     } catch (std::exception& e) {
80992       {
80993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80994       };
80995     } catch (...) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80998       };
80999     }
81000   }
81001   jresult = (void *)result;
81002   return jresult;
81003 }
81004
81005
81006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81007   int jresult ;
81008   int result;
81009
81010   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81011   jresult = (int)result;
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81017   int jresult ;
81018   int result;
81019
81020   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81021   jresult = (int)result;
81022   return jresult;
81023 }
81024
81025
81026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81027   int jresult ;
81028   int result;
81029
81030   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81031   jresult = (int)result;
81032   return jresult;
81033 }
81034
81035
81036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81037   int jresult ;
81038   int result;
81039
81040   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81041   jresult = (int)result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81047   void * jresult ;
81048   Dali::Toolkit::VideoView::Property *result = 0 ;
81049
81050   {
81051     try {
81052       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81053     } catch (std::out_of_range& e) {
81054       {
81055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81056       };
81057     } catch (std::exception& e) {
81058       {
81059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81060       };
81061     } catch (...) {
81062       {
81063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81064       };
81065     }
81066   }
81067   jresult = (void *)result;
81068   return jresult;
81069 }
81070
81071
81072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81073   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81074
81075   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81076   {
81077     try {
81078       delete arg1;
81079     } catch (std::out_of_range& e) {
81080       {
81081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81082       };
81083     } catch (std::exception& e) {
81084       {
81085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81086       };
81087     } catch (...) {
81088       {
81089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81090       };
81091     }
81092   }
81093 }
81094
81095
81096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81097   void * jresult ;
81098   Dali::Toolkit::VideoView result;
81099
81100   {
81101     try {
81102       result = Dali::Toolkit::VideoView::New();
81103     } catch (std::out_of_range& e) {
81104       {
81105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81106       };
81107     } catch (std::exception& e) {
81108       {
81109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81110       };
81111     } catch (...) {
81112       {
81113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81114       };
81115     }
81116   }
81117   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81118   return jresult;
81119 }
81120
81121
81122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81123   void * jresult ;
81124   std::string *arg1 = 0 ;
81125   Dali::Toolkit::VideoView result;
81126
81127   if (!jarg1) {
81128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81129     return 0;
81130   }
81131   std::string arg1_str(jarg1);
81132   arg1 = &arg1_str;
81133   {
81134     try {
81135       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81136     } catch (std::out_of_range& e) {
81137       {
81138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81139       };
81140     } catch (std::exception& e) {
81141       {
81142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81143       };
81144     } catch (...) {
81145       {
81146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81147       };
81148     }
81149   }
81150   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81151
81152   //argout typemap for const std::string&
81153
81154   return jresult;
81155 }
81156
81157
81158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81159   void * jresult ;
81160   Dali::Toolkit::VideoView *result = 0 ;
81161
81162   {
81163     try {
81164       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81165     } catch (std::out_of_range& e) {
81166       {
81167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81168       };
81169     } catch (std::exception& e) {
81170       {
81171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81172       };
81173     } catch (...) {
81174       {
81175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81176       };
81177     }
81178   }
81179   jresult = (void *)result;
81180   return jresult;
81181 }
81182
81183
81184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81185   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81186
81187   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81188   {
81189     try {
81190       delete arg1;
81191     } catch (std::out_of_range& e) {
81192       {
81193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81194       };
81195     } catch (std::exception& e) {
81196       {
81197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81198       };
81199     } catch (...) {
81200       {
81201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81202       };
81203     }
81204   }
81205 }
81206
81207
81208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81209   void * jresult ;
81210   Dali::Toolkit::VideoView *arg1 = 0 ;
81211   Dali::Toolkit::VideoView *result = 0 ;
81212
81213   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81214   if (!arg1) {
81215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81216     return 0;
81217   }
81218   {
81219     try {
81220       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81221     } catch (std::out_of_range& e) {
81222       {
81223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81224       };
81225     } catch (std::exception& e) {
81226       {
81227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81228       };
81229     } catch (...) {
81230       {
81231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81232       };
81233     }
81234   }
81235   jresult = (void *)result;
81236   return jresult;
81237 }
81238
81239
81240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81241   void * jresult ;
81242   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81243   Dali::Toolkit::VideoView *arg2 = 0 ;
81244   Dali::Toolkit::VideoView *result = 0 ;
81245
81246   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81247   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81248   if (!arg2) {
81249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81250     return 0;
81251   }
81252   {
81253     try {
81254       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81255     } catch (std::out_of_range& e) {
81256       {
81257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (std::exception& e) {
81260       {
81261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81262       };
81263     } catch (...) {
81264       {
81265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81266       };
81267     }
81268   }
81269   jresult = (void *)result;
81270   return jresult;
81271 }
81272
81273
81274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81275   void * jresult ;
81276   Dali::BaseHandle arg1 ;
81277   Dali::BaseHandle *argp1 ;
81278   Dali::Toolkit::VideoView result;
81279
81280   argp1 = (Dali::BaseHandle *)jarg1;
81281   if (!argp1) {
81282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81283     return 0;
81284   }
81285   arg1 = *argp1;
81286   {
81287     try {
81288       result = Dali::Toolkit::VideoView::DownCast(arg1);
81289     } catch (std::out_of_range& e) {
81290       {
81291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81292       };
81293     } catch (std::exception& e) {
81294       {
81295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81296       };
81297     } catch (...) {
81298       {
81299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81300       };
81301     }
81302   }
81303   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81304   return jresult;
81305 }
81306
81307
81308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81309   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81310
81311   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81312   {
81313     try {
81314       (arg1)->Play();
81315     } catch (std::out_of_range& e) {
81316       {
81317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81318       };
81319     } catch (std::exception& e) {
81320       {
81321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81322       };
81323     } catch (...) {
81324       {
81325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81326       };
81327     }
81328   }
81329 }
81330
81331
81332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81333   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81334
81335   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81336   {
81337     try {
81338       (arg1)->Pause();
81339     } catch (std::out_of_range& e) {
81340       {
81341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81342       };
81343     } catch (std::exception& e) {
81344       {
81345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81346       };
81347     } catch (...) {
81348       {
81349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81350       };
81351     }
81352   }
81353 }
81354
81355
81356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81357   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81358
81359   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81360   {
81361     try {
81362       (arg1)->Stop();
81363     } catch (std::out_of_range& e) {
81364       {
81365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81366       };
81367     } catch (std::exception& e) {
81368       {
81369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81370       };
81371     } catch (...) {
81372       {
81373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81374       };
81375     }
81376   }
81377 }
81378
81379
81380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81381   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81382   int arg2 ;
81383
81384   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81385   arg2 = (int)jarg2;
81386   {
81387     try {
81388       (arg1)->Forward(arg2);
81389     } catch (std::out_of_range& e) {
81390       {
81391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81392       };
81393     } catch (std::exception& e) {
81394       {
81395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81396       };
81397     } catch (...) {
81398       {
81399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81400       };
81401     }
81402   }
81403 }
81404
81405
81406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81407   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81408   int arg2 ;
81409
81410   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81411   arg2 = (int)jarg2;
81412   {
81413     try {
81414       (arg1)->Backward(arg2);
81415     } catch (std::out_of_range& e) {
81416       {
81417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81418       };
81419     } catch (std::exception& e) {
81420       {
81421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81422       };
81423     } catch (...) {
81424       {
81425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81426       };
81427     }
81428   }
81429 }
81430
81431
81432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81433   void * jresult ;
81434   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81435   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81436
81437   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81438   {
81439     try {
81440       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81441     } catch (std::out_of_range& e) {
81442       {
81443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (std::exception& e) {
81446       {
81447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81448       };
81449     } catch (...) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81452       };
81453     }
81454   }
81455   jresult = (void *)result;
81456   return jresult;
81457 }
81458
81459
81460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81461   int jresult ;
81462   int result;
81463
81464   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81465   jresult = (int)result;
81466   return jresult;
81467 }
81468
81469
81470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81471   int jresult ;
81472   int result;
81473
81474   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81475   jresult = (int)result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81481   int jresult ;
81482   int result;
81483
81484   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81485   jresult = (int)result;
81486   return jresult;
81487 }
81488
81489
81490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81491   int jresult ;
81492   int result;
81493
81494   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81495   jresult = (int)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81501   int jresult ;
81502   int result;
81503
81504   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81505   jresult = (int)result;
81506   return jresult;
81507 }
81508
81509
81510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81511   int jresult ;
81512   int result;
81513
81514   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81515   jresult = (int)result;
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81521   int jresult ;
81522   int result;
81523
81524   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81525   jresult = (int)result;
81526   return jresult;
81527 }
81528
81529
81530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81531   int jresult ;
81532   int result;
81533
81534   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81535   jresult = (int)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81541   int jresult ;
81542   int result;
81543
81544   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81545   jresult = (int)result;
81546   return jresult;
81547 }
81548
81549
81550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81551   int jresult ;
81552   int result;
81553
81554   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81555   jresult = (int)result;
81556   return jresult;
81557 }
81558
81559
81560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81561   int jresult ;
81562   int result;
81563
81564   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81565   jresult = (int)result;
81566   return jresult;
81567 }
81568
81569
81570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81571   int jresult ;
81572   int result;
81573
81574   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81575   jresult = (int)result;
81576   return jresult;
81577 }
81578
81579
81580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81581   int jresult ;
81582   int result;
81583
81584   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81585   jresult = (int)result;
81586   return jresult;
81587 }
81588
81589
81590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81591   int jresult ;
81592   int result;
81593
81594   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81595   jresult = (int)result;
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81601   int jresult ;
81602   int result;
81603
81604   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81605   jresult = (int)result;
81606   return jresult;
81607 }
81608
81609
81610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81611   int jresult ;
81612   int result;
81613
81614   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81615   jresult = (int)result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81621   int jresult ;
81622   int result;
81623
81624   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81625   jresult = (int)result;
81626   return jresult;
81627 }
81628
81629
81630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81631   int jresult ;
81632   int result;
81633
81634   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81635   jresult = (int)result;
81636   return jresult;
81637 }
81638
81639
81640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81641   int jresult ;
81642   int result;
81643
81644   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81645   jresult = (int)result;
81646   return jresult;
81647 }
81648
81649
81650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81651   int jresult ;
81652   int result;
81653
81654   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81655   jresult = (int)result;
81656   return jresult;
81657 }
81658
81659
81660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81661   int jresult ;
81662   int result;
81663
81664   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81665   jresult = (int)result;
81666   return jresult;
81667 }
81668
81669
81670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81671   void * jresult ;
81672   Dali::Toolkit::Popup::Property *result = 0 ;
81673
81674   {
81675     try {
81676       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81677     } catch (std::out_of_range& e) {
81678       {
81679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81680       };
81681     } catch (std::exception& e) {
81682       {
81683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81684       };
81685     } catch (...) {
81686       {
81687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81688       };
81689     }
81690   }
81691   jresult = (void *)result;
81692   return jresult;
81693 }
81694
81695
81696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81697   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81698
81699   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81700   {
81701     try {
81702       delete arg1;
81703     } catch (std::out_of_range& e) {
81704       {
81705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81706       };
81707     } catch (std::exception& e) {
81708       {
81709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81710       };
81711     } catch (...) {
81712       {
81713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81714       };
81715     }
81716   }
81717 }
81718
81719
81720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81721   void * jresult ;
81722   Dali::Toolkit::Popup *result = 0 ;
81723
81724   {
81725     try {
81726       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81727     } catch (std::out_of_range& e) {
81728       {
81729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81730       };
81731     } catch (std::exception& e) {
81732       {
81733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81734       };
81735     } catch (...) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81738       };
81739     }
81740   }
81741   jresult = (void *)result;
81742   return jresult;
81743 }
81744
81745
81746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81747   void * jresult ;
81748   Dali::Toolkit::Popup result;
81749
81750   {
81751     try {
81752       result = Dali::Toolkit::Popup::New();
81753     } catch (std::out_of_range& e) {
81754       {
81755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81756       };
81757     } catch (std::exception& e) {
81758       {
81759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81764       };
81765     }
81766   }
81767   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81768   return jresult;
81769 }
81770
81771
81772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81773   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81774
81775   arg1 = (Dali::Toolkit::Popup *)jarg1;
81776   {
81777     try {
81778       delete arg1;
81779     } catch (std::out_of_range& e) {
81780       {
81781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81782       };
81783     } catch (std::exception& e) {
81784       {
81785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81786       };
81787     } catch (...) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81790       };
81791     }
81792   }
81793 }
81794
81795
81796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81797   void * jresult ;
81798   Dali::Toolkit::Popup *arg1 = 0 ;
81799   Dali::Toolkit::Popup *result = 0 ;
81800
81801   arg1 = (Dali::Toolkit::Popup *)jarg1;
81802   if (!arg1) {
81803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81804     return 0;
81805   }
81806   {
81807     try {
81808       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81809     } catch (std::out_of_range& e) {
81810       {
81811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81812       };
81813     } catch (std::exception& e) {
81814       {
81815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81816       };
81817     } catch (...) {
81818       {
81819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81820       };
81821     }
81822   }
81823   jresult = (void *)result;
81824   return jresult;
81825 }
81826
81827
81828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81829   void * jresult ;
81830   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81831   Dali::Toolkit::Popup *arg2 = 0 ;
81832   Dali::Toolkit::Popup *result = 0 ;
81833
81834   arg1 = (Dali::Toolkit::Popup *)jarg1;
81835   arg2 = (Dali::Toolkit::Popup *)jarg2;
81836   if (!arg2) {
81837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81838     return 0;
81839   }
81840   {
81841     try {
81842       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81843     } catch (std::out_of_range& e) {
81844       {
81845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81846       };
81847     } catch (std::exception& e) {
81848       {
81849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81854       };
81855     }
81856   }
81857   jresult = (void *)result;
81858   return jresult;
81859 }
81860
81861
81862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81863   void * jresult ;
81864   Dali::BaseHandle arg1 ;
81865   Dali::BaseHandle *argp1 ;
81866   Dali::Toolkit::Popup result;
81867
81868   argp1 = (Dali::BaseHandle *)jarg1;
81869   if (!argp1) {
81870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81871     return 0;
81872   }
81873   arg1 = *argp1;
81874   {
81875     try {
81876       result = Dali::Toolkit::Popup::DownCast(arg1);
81877     } catch (std::out_of_range& e) {
81878       {
81879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81880       };
81881     } catch (std::exception& e) {
81882       {
81883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81884       };
81885     } catch (...) {
81886       {
81887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81888       };
81889     }
81890   }
81891   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81892   return jresult;
81893 }
81894
81895
81896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81897   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81898   Dali::Actor arg2 ;
81899   Dali::Actor *argp2 ;
81900
81901   arg1 = (Dali::Toolkit::Popup *)jarg1;
81902   argp2 = (Dali::Actor *)jarg2;
81903   if (!argp2) {
81904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81905     return ;
81906   }
81907   arg2 = *argp2;
81908   {
81909     try {
81910       (arg1)->SetTitle(arg2);
81911     } catch (std::out_of_range& e) {
81912       {
81913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81914       };
81915     } catch (std::exception& e) {
81916       {
81917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81918       };
81919     } catch (...) {
81920       {
81921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81922       };
81923     }
81924   }
81925 }
81926
81927
81928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81929   void * jresult ;
81930   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81931   Dali::Actor result;
81932
81933   arg1 = (Dali::Toolkit::Popup *)jarg1;
81934   {
81935     try {
81936       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81937     } catch (std::out_of_range& e) {
81938       {
81939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81940       };
81941     } catch (std::exception& e) {
81942       {
81943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81944       };
81945     } catch (...) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81948       };
81949     }
81950   }
81951   jresult = new Dali::Actor((const Dali::Actor &)result);
81952   return jresult;
81953 }
81954
81955
81956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81957   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81958   Dali::Actor arg2 ;
81959   Dali::Actor *argp2 ;
81960
81961   arg1 = (Dali::Toolkit::Popup *)jarg1;
81962   argp2 = (Dali::Actor *)jarg2;
81963   if (!argp2) {
81964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81965     return ;
81966   }
81967   arg2 = *argp2;
81968   {
81969     try {
81970       (arg1)->SetContent(arg2);
81971     } catch (std::out_of_range& e) {
81972       {
81973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81974       };
81975     } catch (std::exception& e) {
81976       {
81977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81978       };
81979     } catch (...) {
81980       {
81981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81982       };
81983     }
81984   }
81985 }
81986
81987
81988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81989   void * jresult ;
81990   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81991   Dali::Actor result;
81992
81993   arg1 = (Dali::Toolkit::Popup *)jarg1;
81994   {
81995     try {
81996       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
81997     } catch (std::out_of_range& e) {
81998       {
81999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82000       };
82001     } catch (std::exception& e) {
82002       {
82003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82004       };
82005     } catch (...) {
82006       {
82007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82008       };
82009     }
82010   }
82011   jresult = new Dali::Actor((const Dali::Actor &)result);
82012   return jresult;
82013 }
82014
82015
82016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82017   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82018   Dali::Actor arg2 ;
82019   Dali::Actor *argp2 ;
82020
82021   arg1 = (Dali::Toolkit::Popup *)jarg1;
82022   argp2 = (Dali::Actor *)jarg2;
82023   if (!argp2) {
82024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82025     return ;
82026   }
82027   arg2 = *argp2;
82028   {
82029     try {
82030       (arg1)->SetFooter(arg2);
82031     } catch (std::out_of_range& e) {
82032       {
82033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82034       };
82035     } catch (std::exception& e) {
82036       {
82037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82038       };
82039     } catch (...) {
82040       {
82041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82042       };
82043     }
82044   }
82045 }
82046
82047
82048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82049   void * jresult ;
82050   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82051   Dali::Actor result;
82052
82053   arg1 = (Dali::Toolkit::Popup *)jarg1;
82054   {
82055     try {
82056       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82057     } catch (std::out_of_range& e) {
82058       {
82059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82060       };
82061     } catch (std::exception& e) {
82062       {
82063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (...) {
82066       {
82067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82068       };
82069     }
82070   }
82071   jresult = new Dali::Actor((const Dali::Actor &)result);
82072   return jresult;
82073 }
82074
82075
82076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82077   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82078   Dali::Toolkit::Popup::DisplayState arg2 ;
82079
82080   arg1 = (Dali::Toolkit::Popup *)jarg1;
82081   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82082   {
82083     try {
82084       (arg1)->SetDisplayState(arg2);
82085     } catch (std::out_of_range& e) {
82086       {
82087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82088       };
82089     } catch (std::exception& e) {
82090       {
82091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82092       };
82093     } catch (...) {
82094       {
82095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82096       };
82097     }
82098   }
82099 }
82100
82101
82102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82103   int jresult ;
82104   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82105   Dali::Toolkit::Popup::DisplayState result;
82106
82107   arg1 = (Dali::Toolkit::Popup *)jarg1;
82108   {
82109     try {
82110       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82111     } catch (std::out_of_range& e) {
82112       {
82113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82114       };
82115     } catch (std::exception& e) {
82116       {
82117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82118       };
82119     } catch (...) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82122       };
82123     }
82124   }
82125   jresult = (int)result;
82126   return jresult;
82127 }
82128
82129
82130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82131   void * jresult ;
82132   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82133   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82134
82135   arg1 = (Dali::Toolkit::Popup *)jarg1;
82136   {
82137     try {
82138       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82139     } catch (std::out_of_range& e) {
82140       {
82141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82142       };
82143     } catch (std::exception& e) {
82144       {
82145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82146       };
82147     } catch (...) {
82148       {
82149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82150       };
82151     }
82152   }
82153   jresult = (void *)result;
82154   return jresult;
82155 }
82156
82157
82158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82159   void * jresult ;
82160   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82161   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82162
82163   arg1 = (Dali::Toolkit::Popup *)jarg1;
82164   {
82165     try {
82166       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82167     } catch (std::out_of_range& e) {
82168       {
82169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82170       };
82171     } catch (std::exception& e) {
82172       {
82173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82174       };
82175     } catch (...) {
82176       {
82177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82178       };
82179     }
82180   }
82181   jresult = (void *)result;
82182   return jresult;
82183 }
82184
82185
82186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82187   void * jresult ;
82188   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82189   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82190
82191   arg1 = (Dali::Toolkit::Popup *)jarg1;
82192   {
82193     try {
82194       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82195     } catch (std::out_of_range& e) {
82196       {
82197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82198       };
82199     } catch (std::exception& e) {
82200       {
82201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82202       };
82203     } catch (...) {
82204       {
82205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82206       };
82207     }
82208   }
82209   jresult = (void *)result;
82210   return jresult;
82211 }
82212
82213
82214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82215   void * jresult ;
82216   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82217   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82218
82219   arg1 = (Dali::Toolkit::Popup *)jarg1;
82220   {
82221     try {
82222       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82223     } catch (std::out_of_range& e) {
82224       {
82225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (std::exception& e) {
82228       {
82229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (...) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82234       };
82235     }
82236   }
82237   jresult = (void *)result;
82238   return jresult;
82239 }
82240
82241
82242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82243   void * jresult ;
82244   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82245   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82246
82247   arg1 = (Dali::Toolkit::Popup *)jarg1;
82248   {
82249     try {
82250       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82251     } catch (std::out_of_range& e) {
82252       {
82253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (std::exception& e) {
82256       {
82257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82262       };
82263     }
82264   }
82265   jresult = (void *)result;
82266   return jresult;
82267 }
82268
82269
82270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82271   int jresult ;
82272   int result;
82273
82274   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82275   jresult = (int)result;
82276   return jresult;
82277 }
82278
82279
82280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82281   int jresult ;
82282   int result;
82283
82284   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82285   jresult = (int)result;
82286   return jresult;
82287 }
82288
82289
82290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82291   int jresult ;
82292   int result;
82293
82294   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82295   jresult = (int)result;
82296   return jresult;
82297 }
82298
82299
82300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82301   int jresult ;
82302   int result;
82303
82304   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82305   jresult = (int)result;
82306   return jresult;
82307 }
82308
82309
82310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82311   int jresult ;
82312   int result;
82313
82314   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82315   jresult = (int)result;
82316   return jresult;
82317 }
82318
82319
82320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82321   int jresult ;
82322   int result;
82323
82324   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82325   jresult = (int)result;
82326   return jresult;
82327 }
82328
82329
82330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82331   int jresult ;
82332   int result;
82333
82334   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82335   jresult = (int)result;
82336   return jresult;
82337 }
82338
82339
82340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82341   int jresult ;
82342   int result;
82343
82344   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82345   jresult = (int)result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82351   int jresult ;
82352   int result;
82353
82354   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82355   jresult = (int)result;
82356   return jresult;
82357 }
82358
82359
82360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82361   void * jresult ;
82362   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82363
82364   {
82365     try {
82366       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82367     } catch (std::out_of_range& e) {
82368       {
82369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (std::exception& e) {
82372       {
82373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (...) {
82376       {
82377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82378       };
82379     }
82380   }
82381   jresult = (void *)result;
82382   return jresult;
82383 }
82384
82385
82386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82387   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82388
82389   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82390   {
82391     try {
82392       delete arg1;
82393     } catch (std::out_of_range& e) {
82394       {
82395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82396       };
82397     } catch (std::exception& e) {
82398       {
82399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82400       };
82401     } catch (...) {
82402       {
82403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82404       };
82405     }
82406   }
82407 }
82408
82409
82410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82411   void * jresult ;
82412   Dali::Toolkit::ProgressBar result;
82413
82414   {
82415     try {
82416       result = Dali::Toolkit::ProgressBar::New();
82417     } catch (std::out_of_range& e) {
82418       {
82419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82420       };
82421     } catch (std::exception& e) {
82422       {
82423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82424       };
82425     } catch (...) {
82426       {
82427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82428       };
82429     }
82430   }
82431   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82432   return jresult;
82433 }
82434
82435
82436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82437   void * jresult ;
82438   Dali::Toolkit::ProgressBar *result = 0 ;
82439
82440   {
82441     try {
82442       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82443     } catch (std::out_of_range& e) {
82444       {
82445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82446       };
82447     } catch (std::exception& e) {
82448       {
82449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82450       };
82451     } catch (...) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82454       };
82455     }
82456   }
82457   jresult = (void *)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82463   void * jresult ;
82464   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82465   Dali::Toolkit::ProgressBar *result = 0 ;
82466
82467   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82468   if (!arg1) {
82469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82470     return 0;
82471   }
82472   {
82473     try {
82474       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82475     } catch (std::out_of_range& e) {
82476       {
82477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82478       };
82479     } catch (std::exception& e) {
82480       {
82481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82482       };
82483     } catch (...) {
82484       {
82485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82486       };
82487     }
82488   }
82489   jresult = (void *)result;
82490   return jresult;
82491 }
82492
82493
82494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82495   void * jresult ;
82496   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82497   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82498   Dali::Toolkit::ProgressBar *result = 0 ;
82499
82500   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82501   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82502   if (!arg2) {
82503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82504     return 0;
82505   }
82506   {
82507     try {
82508       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82509     } catch (std::out_of_range& e) {
82510       {
82511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82512       };
82513     } catch (std::exception& e) {
82514       {
82515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82516       };
82517     } catch (...) {
82518       {
82519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82520       };
82521     }
82522   }
82523   jresult = (void *)result;
82524   return jresult;
82525 }
82526
82527
82528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82529   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82530
82531   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82532   {
82533     try {
82534       delete arg1;
82535     } catch (std::out_of_range& e) {
82536       {
82537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82538       };
82539     } catch (std::exception& e) {
82540       {
82541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82542       };
82543     } catch (...) {
82544       {
82545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82546       };
82547     }
82548   }
82549 }
82550
82551
82552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82553   void * jresult ;
82554   Dali::BaseHandle arg1 ;
82555   Dali::BaseHandle *argp1 ;
82556   Dali::Toolkit::ProgressBar result;
82557
82558   argp1 = (Dali::BaseHandle *)jarg1;
82559   if (!argp1) {
82560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82561     return 0;
82562   }
82563   arg1 = *argp1;
82564   {
82565     try {
82566       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82567     } catch (std::out_of_range& e) {
82568       {
82569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82570       };
82571     } catch (std::exception& e) {
82572       {
82573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82574       };
82575     } catch (...) {
82576       {
82577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82578       };
82579     }
82580   }
82581   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82582   return jresult;
82583 }
82584
82585
82586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82587   void * jresult ;
82588   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82589   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82590
82591   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82592   {
82593     try {
82594       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82595     } catch (std::out_of_range& e) {
82596       {
82597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82598       };
82599     } catch (std::exception& e) {
82600       {
82601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82602       };
82603     } catch (...) {
82604       {
82605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82606       };
82607     }
82608   }
82609   jresult = (void *)result;
82610   return jresult;
82611 }
82612
82613
82614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82615   void * jresult ;
82616   Dali::Toolkit::GaussianBlurView *result = 0 ;
82617
82618   {
82619     try {
82620       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82621     } catch (std::out_of_range& e) {
82622       {
82623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82624       };
82625     } catch (std::exception& e) {
82626       {
82627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82628       };
82629     } catch (...) {
82630       {
82631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82632       };
82633     }
82634   }
82635   jresult = (void *)result;
82636   return jresult;
82637 }
82638
82639
82640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82641   void * jresult ;
82642   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82643   Dali::Toolkit::GaussianBlurView *result = 0 ;
82644
82645   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82646   if (!arg1) {
82647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82648     return 0;
82649   }
82650   {
82651     try {
82652       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82653     } catch (std::out_of_range& e) {
82654       {
82655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (std::exception& e) {
82658       {
82659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82664       };
82665     }
82666   }
82667   jresult = (void *)result;
82668   return jresult;
82669 }
82670
82671
82672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82673   void * jresult ;
82674   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82675   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82676   Dali::Toolkit::GaussianBlurView *result = 0 ;
82677
82678   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82679   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82680   if (!arg2) {
82681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82682     return 0;
82683   }
82684   {
82685     try {
82686       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82698       };
82699     }
82700   }
82701   jresult = (void *)result;
82702   return jresult;
82703 }
82704
82705
82706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82707   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82708
82709   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82710   {
82711     try {
82712       delete arg1;
82713     } catch (std::out_of_range& e) {
82714       {
82715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82716       };
82717     } catch (std::exception& e) {
82718       {
82719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82720       };
82721     } catch (...) {
82722       {
82723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82724       };
82725     }
82726   }
82727 }
82728
82729
82730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82731   void * jresult ;
82732   Dali::BaseHandle arg1 ;
82733   Dali::BaseHandle *argp1 ;
82734   Dali::Toolkit::GaussianBlurView result;
82735
82736   argp1 = (Dali::BaseHandle *)jarg1;
82737   if (!argp1) {
82738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82739     return 0;
82740   }
82741   arg1 = *argp1;
82742   {
82743     try {
82744       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82745     } catch (std::out_of_range& e) {
82746       {
82747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82748       };
82749     } catch (std::exception& e) {
82750       {
82751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82752       };
82753     } catch (...) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82756       };
82757     }
82758   }
82759   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82760   return jresult;
82761 }
82762
82763
82764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82765   void * jresult ;
82766   Dali::Toolkit::GaussianBlurView result;
82767
82768   {
82769     try {
82770       result = Dali::Toolkit::GaussianBlurView::New();
82771     } catch (std::out_of_range& e) {
82772       {
82773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (std::exception& e) {
82776       {
82777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82778       };
82779     } catch (...) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82782       };
82783     }
82784   }
82785   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82786   return jresult;
82787 }
82788
82789
82790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82791   void * jresult ;
82792   unsigned int arg1 ;
82793   float arg2 ;
82794   Dali::Pixel::Format arg3 ;
82795   float arg4 ;
82796   float arg5 ;
82797   bool arg6 ;
82798   Dali::Toolkit::GaussianBlurView result;
82799
82800   arg1 = (unsigned int)jarg1;
82801   arg2 = (float)jarg2;
82802   arg3 = (Dali::Pixel::Format)jarg3;
82803   arg4 = (float)jarg4;
82804   arg5 = (float)jarg5;
82805   arg6 = jarg6 ? true : false;
82806   {
82807     try {
82808       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82809     } catch (std::out_of_range& e) {
82810       {
82811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82812       };
82813     } catch (std::exception& e) {
82814       {
82815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82816       };
82817     } catch (...) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82820       };
82821     }
82822   }
82823   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82824   return jresult;
82825 }
82826
82827
82828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82829   void * jresult ;
82830   unsigned int arg1 ;
82831   float arg2 ;
82832   Dali::Pixel::Format arg3 ;
82833   float arg4 ;
82834   float arg5 ;
82835   Dali::Toolkit::GaussianBlurView result;
82836
82837   arg1 = (unsigned int)jarg1;
82838   arg2 = (float)jarg2;
82839   arg3 = (Dali::Pixel::Format)jarg3;
82840   arg4 = (float)jarg4;
82841   arg5 = (float)jarg5;
82842   {
82843     try {
82844       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82845     } catch (std::out_of_range& e) {
82846       {
82847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82848       };
82849     } catch (std::exception& e) {
82850       {
82851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (...) {
82854       {
82855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82856       };
82857     }
82858   }
82859   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82865   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82866   Dali::Actor arg2 ;
82867   Dali::Actor *argp2 ;
82868
82869   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82870   argp2 = (Dali::Actor *)jarg2;
82871   if (!argp2) {
82872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82873     return ;
82874   }
82875   arg2 = *argp2;
82876   {
82877     try {
82878       (arg1)->Add(arg2);
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82886       };
82887     } catch (...) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82890       };
82891     }
82892   }
82893 }
82894
82895
82896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82897   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82898   Dali::Actor arg2 ;
82899   Dali::Actor *argp2 ;
82900
82901   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82902   argp2 = (Dali::Actor *)jarg2;
82903   if (!argp2) {
82904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82905     return ;
82906   }
82907   arg2 = *argp2;
82908   {
82909     try {
82910       (arg1)->Remove(arg2);
82911     } catch (std::out_of_range& e) {
82912       {
82913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82914       };
82915     } catch (std::exception& e) {
82916       {
82917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82918       };
82919     } catch (...) {
82920       {
82921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82922       };
82923     }
82924   }
82925 }
82926
82927
82928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82929   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82930
82931   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82932   {
82933     try {
82934       (arg1)->Activate();
82935     } catch (std::out_of_range& e) {
82936       {
82937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82938       };
82939     } catch (std::exception& e) {
82940       {
82941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82942       };
82943     } catch (...) {
82944       {
82945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82946       };
82947     }
82948   }
82949 }
82950
82951
82952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82953   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82954
82955   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82956   {
82957     try {
82958       (arg1)->ActivateOnce();
82959     } catch (std::out_of_range& e) {
82960       {
82961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82962       };
82963     } catch (std::exception& e) {
82964       {
82965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82966       };
82967     } catch (...) {
82968       {
82969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82970       };
82971     }
82972   }
82973 }
82974
82975
82976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82977   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82978
82979   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82980   {
82981     try {
82982       (arg1)->Deactivate();
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (...) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82994       };
82995     }
82996   }
82997 }
82998
82999
83000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83001   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83002   Dali::Image arg2 ;
83003   Dali::FrameBufferImage arg3 ;
83004   Dali::Image *argp2 ;
83005   Dali::FrameBufferImage *argp3 ;
83006
83007   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83008   argp2 = (Dali::Image *)jarg2;
83009   if (!argp2) {
83010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83011     return ;
83012   }
83013   arg2 = *argp2;
83014   argp3 = (Dali::FrameBufferImage *)jarg3;
83015   if (!argp3) {
83016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83017     return ;
83018   }
83019   arg3 = *argp3;
83020   {
83021     try {
83022       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83023     } catch (std::out_of_range& e) {
83024       {
83025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83026       };
83027     } catch (std::exception& e) {
83028       {
83029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83030       };
83031     } catch (...) {
83032       {
83033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83034       };
83035     }
83036   }
83037 }
83038
83039
83040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83041   int jresult ;
83042   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83043   Dali::Property::Index result;
83044
83045   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83046   {
83047     try {
83048       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83049     } catch (std::out_of_range& e) {
83050       {
83051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (std::exception& e) {
83054       {
83055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (...) {
83058       {
83059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83060       };
83061     }
83062   }
83063   jresult = result;
83064   return jresult;
83065 }
83066
83067
83068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83069   void * jresult ;
83070   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83071   Dali::FrameBufferImage result;
83072
83073   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83074   {
83075     try {
83076       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83077     } catch (std::out_of_range& e) {
83078       {
83079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83080       };
83081     } catch (std::exception& e) {
83082       {
83083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83084       };
83085     } catch (...) {
83086       {
83087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83088       };
83089     }
83090   }
83091   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83092   return jresult;
83093 }
83094
83095
83096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83097   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83098   Dali::Vector4 *arg2 = 0 ;
83099
83100   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83101   arg2 = (Dali::Vector4 *)jarg2;
83102   if (!arg2) {
83103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83104     return ;
83105   }
83106   {
83107     try {
83108       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83109     } catch (std::out_of_range& e) {
83110       {
83111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83112       };
83113     } catch (std::exception& e) {
83114       {
83115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83120       };
83121     }
83122   }
83123 }
83124
83125
83126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83127   void * jresult ;
83128   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83129   Dali::Vector4 result;
83130
83131   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83132   {
83133     try {
83134       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83135     } catch (std::out_of_range& e) {
83136       {
83137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83138       };
83139     } catch (std::exception& e) {
83140       {
83141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83142       };
83143     } catch (...) {
83144       {
83145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83146       };
83147     }
83148   }
83149   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83150   return jresult;
83151 }
83152
83153
83154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83155   void * jresult ;
83156   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83157   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83158
83159   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83160   {
83161     try {
83162       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83163     } catch (std::out_of_range& e) {
83164       {
83165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83166       };
83167     } catch (std::exception& e) {
83168       {
83169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83170       };
83171     } catch (...) {
83172       {
83173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83174       };
83175     }
83176   }
83177   jresult = (void *)result;
83178   return jresult;
83179 }
83180
83181
83182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83183   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83184
83185   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83186   {
83187     try {
83188       delete arg1;
83189     } catch (std::out_of_range& e) {
83190       {
83191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83192       };
83193     } catch (std::exception& e) {
83194       {
83195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83200       };
83201     }
83202   }
83203 }
83204
83205
83206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83207   unsigned int jresult ;
83208   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83209   unsigned int result;
83210
83211   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83212   {
83213     try {
83214       result = (unsigned int)(arg1)->GetNumberOfPages();
83215     } catch (std::out_of_range& e) {
83216       {
83217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83218       };
83219     } catch (std::exception& e) {
83220       {
83221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83222       };
83223     } catch (...) {
83224       {
83225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83226       };
83227     }
83228   }
83229   jresult = result;
83230   return jresult;
83231 }
83232
83233
83234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83235   void * jresult ;
83236   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83237   unsigned int arg2 ;
83238   Dali::Texture result;
83239
83240   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83241   arg2 = (unsigned int)jarg2;
83242   {
83243     try {
83244       result = (arg1)->NewPage(arg2);
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83256       };
83257     }
83258   }
83259   jresult = new Dali::Texture((const Dali::Texture &)result);
83260   return jresult;
83261 }
83262
83263
83264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83265   int jresult ;
83266   int result;
83267
83268   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83269   jresult = (int)result;
83270   return jresult;
83271 }
83272
83273
83274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83275   int jresult ;
83276   int result;
83277
83278   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83279   jresult = (int)result;
83280   return jresult;
83281 }
83282
83283
83284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83285   int jresult ;
83286   int result;
83287
83288   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83289   jresult = (int)result;
83290   return jresult;
83291 }
83292
83293
83294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83295   void * jresult ;
83296   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83297
83298   {
83299     try {
83300       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83301     } catch (std::out_of_range& e) {
83302       {
83303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83304       };
83305     } catch (std::exception& e) {
83306       {
83307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (...) {
83310       {
83311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83312       };
83313     }
83314   }
83315   jresult = (void *)result;
83316   return jresult;
83317 }
83318
83319
83320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83321   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83322
83323   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83324   {
83325     try {
83326       delete arg1;
83327     } catch (std::out_of_range& e) {
83328       {
83329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83330       };
83331     } catch (std::exception& e) {
83332       {
83333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83334       };
83335     } catch (...) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83338       };
83339     }
83340   }
83341 }
83342
83343
83344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83345   void * jresult ;
83346   Dali::Toolkit::PageTurnView *result = 0 ;
83347
83348   {
83349     try {
83350       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83351     } catch (std::out_of_range& e) {
83352       {
83353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83354       };
83355     } catch (std::exception& e) {
83356       {
83357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83358       };
83359     } catch (...) {
83360       {
83361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83362       };
83363     }
83364   }
83365   jresult = (void *)result;
83366   return jresult;
83367 }
83368
83369
83370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83371   void * jresult ;
83372   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83373   Dali::Toolkit::PageTurnView *result = 0 ;
83374
83375   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83376   if (!arg1) {
83377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83378     return 0;
83379   }
83380   {
83381     try {
83382       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83383     } catch (std::out_of_range& e) {
83384       {
83385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (std::exception& e) {
83388       {
83389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83394       };
83395     }
83396   }
83397   jresult = (void *)result;
83398   return jresult;
83399 }
83400
83401
83402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83403   void * jresult ;
83404   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83405   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83406   Dali::Toolkit::PageTurnView *result = 0 ;
83407
83408   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83409   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83410   if (!arg2) {
83411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83412     return 0;
83413   }
83414   {
83415     try {
83416       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83417     } catch (std::out_of_range& e) {
83418       {
83419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (std::exception& e) {
83422       {
83423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83424       };
83425     } catch (...) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83428       };
83429     }
83430   }
83431   jresult = (void *)result;
83432   return jresult;
83433 }
83434
83435
83436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83437   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83438
83439   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83440   {
83441     try {
83442       delete arg1;
83443     } catch (std::out_of_range& e) {
83444       {
83445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83446       };
83447     } catch (std::exception& e) {
83448       {
83449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83454       };
83455     }
83456   }
83457 }
83458
83459
83460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83461   void * jresult ;
83462   Dali::BaseHandle arg1 ;
83463   Dali::BaseHandle *argp1 ;
83464   Dali::Toolkit::PageTurnView result;
83465
83466   argp1 = (Dali::BaseHandle *)jarg1;
83467   if (!argp1) {
83468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83469     return 0;
83470   }
83471   arg1 = *argp1;
83472   {
83473     try {
83474       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (...) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83486       };
83487     }
83488   }
83489   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83490   return jresult;
83491 }
83492
83493
83494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83495   void * jresult ;
83496   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83497   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83498
83499   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83500   {
83501     try {
83502       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83503     } catch (std::out_of_range& e) {
83504       {
83505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83506       };
83507     } catch (std::exception& e) {
83508       {
83509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83510       };
83511     } catch (...) {
83512       {
83513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83514       };
83515     }
83516   }
83517   jresult = (void *)result;
83518   return jresult;
83519 }
83520
83521
83522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83523   void * jresult ;
83524   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83525   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83526
83527   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83528   {
83529     try {
83530       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83531     } catch (std::out_of_range& e) {
83532       {
83533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83534       };
83535     } catch (std::exception& e) {
83536       {
83537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83538       };
83539     } catch (...) {
83540       {
83541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83542       };
83543     }
83544   }
83545   jresult = (void *)result;
83546   return jresult;
83547 }
83548
83549
83550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83551   void * jresult ;
83552   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83553   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83554
83555   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83556   {
83557     try {
83558       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83559     } catch (std::out_of_range& e) {
83560       {
83561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (std::exception& e) {
83564       {
83565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83566       };
83567     } catch (...) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83570       };
83571     }
83572   }
83573   jresult = (void *)result;
83574   return jresult;
83575 }
83576
83577
83578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83579   void * jresult ;
83580   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83581   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83582
83583   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83584   {
83585     try {
83586       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83587     } catch (std::out_of_range& e) {
83588       {
83589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83590       };
83591     } catch (std::exception& e) {
83592       {
83593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (...) {
83596       {
83597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83598       };
83599     }
83600   }
83601   jresult = (void *)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83607   void * jresult ;
83608   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83609
83610   {
83611     try {
83612       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83613     } catch (std::out_of_range& e) {
83614       {
83615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83616       };
83617     } catch (std::exception& e) {
83618       {
83619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83620       };
83621     } catch (...) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83624       };
83625     }
83626   }
83627   jresult = (void *)result;
83628   return jresult;
83629 }
83630
83631
83632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83633   void * jresult ;
83634   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83635   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83636
83637   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83638   if (!arg1) {
83639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83640     return 0;
83641   }
83642   {
83643     try {
83644       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83645     } catch (std::out_of_range& e) {
83646       {
83647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (std::exception& e) {
83650       {
83651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83652       };
83653     } catch (...) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83656       };
83657     }
83658   }
83659   jresult = (void *)result;
83660   return jresult;
83661 }
83662
83663
83664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83665   void * jresult ;
83666   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83667   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83668   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83669
83670   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83671   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83672   if (!arg2) {
83673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83674     return 0;
83675   }
83676   {
83677     try {
83678       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83679     } catch (std::out_of_range& e) {
83680       {
83681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83682       };
83683     } catch (std::exception& e) {
83684       {
83685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83686       };
83687     } catch (...) {
83688       {
83689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83690       };
83691     }
83692   }
83693   jresult = (void *)result;
83694   return jresult;
83695 }
83696
83697
83698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83699   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83700
83701   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83702   {
83703     try {
83704       delete arg1;
83705     } catch (std::out_of_range& e) {
83706       {
83707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83708       };
83709     } catch (std::exception& e) {
83710       {
83711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83712       };
83713     } catch (...) {
83714       {
83715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83716       };
83717     }
83718   }
83719 }
83720
83721
83722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83723   void * jresult ;
83724   Dali::Toolkit::PageFactory *arg1 = 0 ;
83725   Dali::Vector2 *arg2 = 0 ;
83726   Dali::Toolkit::PageTurnLandscapeView result;
83727
83728   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83729   if (!arg1) {
83730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83731     return 0;
83732   }
83733   arg2 = (Dali::Vector2 *)jarg2;
83734   if (!arg2) {
83735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83736     return 0;
83737   }
83738   {
83739     try {
83740       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83741     } catch (std::out_of_range& e) {
83742       {
83743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83744       };
83745     } catch (std::exception& e) {
83746       {
83747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83748       };
83749     } catch (...) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83752       };
83753     }
83754   }
83755   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83756   return jresult;
83757 }
83758
83759
83760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83761   void * jresult ;
83762   Dali::BaseHandle arg1 ;
83763   Dali::BaseHandle *argp1 ;
83764   Dali::Toolkit::PageTurnLandscapeView result;
83765
83766   argp1 = (Dali::BaseHandle *)jarg1;
83767   if (!argp1) {
83768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83769     return 0;
83770   }
83771   arg1 = *argp1;
83772   {
83773     try {
83774       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83775     } catch (std::out_of_range& e) {
83776       {
83777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83778       };
83779     } catch (std::exception& e) {
83780       {
83781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (...) {
83784       {
83785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83786       };
83787     }
83788   }
83789   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83790   return jresult;
83791 }
83792
83793
83794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83795   void * jresult ;
83796   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83797
83798   {
83799     try {
83800       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83801     } catch (std::out_of_range& e) {
83802       {
83803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83804       };
83805     } catch (std::exception& e) {
83806       {
83807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83808       };
83809     } catch (...) {
83810       {
83811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83812       };
83813     }
83814   }
83815   jresult = (void *)result;
83816   return jresult;
83817 }
83818
83819
83820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83821   void * jresult ;
83822   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83823   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83824
83825   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83826   if (!arg1) {
83827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83828     return 0;
83829   }
83830   {
83831     try {
83832       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83844       };
83845     }
83846   }
83847   jresult = (void *)result;
83848   return jresult;
83849 }
83850
83851
83852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83853   void * jresult ;
83854   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83855   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83856   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83857
83858   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83859   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83860   if (!arg2) {
83861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83862     return 0;
83863   }
83864   {
83865     try {
83866       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83867     } catch (std::out_of_range& e) {
83868       {
83869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83870       };
83871     } catch (std::exception& e) {
83872       {
83873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83878       };
83879     }
83880   }
83881   jresult = (void *)result;
83882   return jresult;
83883 }
83884
83885
83886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83887   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83888
83889   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83890   {
83891     try {
83892       delete arg1;
83893     } catch (std::out_of_range& e) {
83894       {
83895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83896       };
83897     } catch (std::exception& e) {
83898       {
83899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83900       };
83901     } catch (...) {
83902       {
83903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83904       };
83905     }
83906   }
83907 }
83908
83909
83910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83911   void * jresult ;
83912   Dali::Toolkit::PageFactory *arg1 = 0 ;
83913   Dali::Vector2 *arg2 = 0 ;
83914   Dali::Toolkit::PageTurnPortraitView result;
83915
83916   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83917   if (!arg1) {
83918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83919     return 0;
83920   }
83921   arg2 = (Dali::Vector2 *)jarg2;
83922   if (!arg2) {
83923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83924     return 0;
83925   }
83926   {
83927     try {
83928       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83929     } catch (std::out_of_range& e) {
83930       {
83931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83932       };
83933     } catch (std::exception& e) {
83934       {
83935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83936       };
83937     } catch (...) {
83938       {
83939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83940       };
83941     }
83942   }
83943   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83944   return jresult;
83945 }
83946
83947
83948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83949   void * jresult ;
83950   Dali::BaseHandle arg1 ;
83951   Dali::BaseHandle *argp1 ;
83952   Dali::Toolkit::PageTurnPortraitView result;
83953
83954   argp1 = (Dali::BaseHandle *)jarg1;
83955   if (!argp1) {
83956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83957     return 0;
83958   }
83959   arg1 = *argp1;
83960   {
83961     try {
83962       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83963     } catch (std::out_of_range& e) {
83964       {
83965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83966       };
83967     } catch (std::exception& e) {
83968       {
83969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83970       };
83971     } catch (...) {
83972       {
83973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83974       };
83975     }
83976   }
83977   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83978   return jresult;
83979 }
83980
83981
83982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83983   int jresult ;
83984   int result;
83985
83986   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83987   jresult = (int)result;
83988   return jresult;
83989 }
83990
83991
83992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
83993   int jresult ;
83994   int result;
83995
83996   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
83997   jresult = (int)result;
83998   return jresult;
83999 }
84000
84001
84002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84003   int jresult ;
84004   int result;
84005
84006   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84007   jresult = (int)result;
84008   return jresult;
84009 }
84010
84011
84012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84013   void * jresult ;
84014   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84015
84016   {
84017     try {
84018       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84019     } catch (std::out_of_range& e) {
84020       {
84021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84022       };
84023     } catch (std::exception& e) {
84024       {
84025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84026       };
84027     } catch (...) {
84028       {
84029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84030       };
84031     }
84032   }
84033   jresult = (void *)result;
84034   return jresult;
84035 }
84036
84037
84038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84039   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84040
84041   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84042   {
84043     try {
84044       delete arg1;
84045     } catch (std::out_of_range& e) {
84046       {
84047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84048       };
84049     } catch (std::exception& e) {
84050       {
84051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84052       };
84053     } catch (...) {
84054       {
84055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84056       };
84057     }
84058   }
84059 }
84060
84061
84062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84063   void * jresult ;
84064   Dali::Toolkit::ToggleButton *result = 0 ;
84065
84066   {
84067     try {
84068       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84069     } catch (std::out_of_range& e) {
84070       {
84071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84072       };
84073     } catch (std::exception& e) {
84074       {
84075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84076       };
84077     } catch (...) {
84078       {
84079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84080       };
84081     }
84082   }
84083   jresult = (void *)result;
84084   return jresult;
84085 }
84086
84087
84088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84089   void * jresult ;
84090   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84091   Dali::Toolkit::ToggleButton *result = 0 ;
84092
84093   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84094   if (!arg1) {
84095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84096     return 0;
84097   }
84098   {
84099     try {
84100       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84101     } catch (std::out_of_range& e) {
84102       {
84103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84104       };
84105     } catch (std::exception& e) {
84106       {
84107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84108       };
84109     } catch (...) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84112       };
84113     }
84114   }
84115   jresult = (void *)result;
84116   return jresult;
84117 }
84118
84119
84120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84121   void * jresult ;
84122   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84123   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84124   Dali::Toolkit::ToggleButton *result = 0 ;
84125
84126   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84127   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84128   if (!arg2) {
84129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84130     return 0;
84131   }
84132   {
84133     try {
84134       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84135     } catch (std::out_of_range& e) {
84136       {
84137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84138       };
84139     } catch (std::exception& e) {
84140       {
84141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84146       };
84147     }
84148   }
84149   jresult = (void *)result;
84150   return jresult;
84151 }
84152
84153
84154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84155   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84156
84157   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84158   {
84159     try {
84160       delete arg1;
84161     } catch (std::out_of_range& e) {
84162       {
84163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84164       };
84165     } catch (std::exception& e) {
84166       {
84167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84168       };
84169     } catch (...) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84172       };
84173     }
84174   }
84175 }
84176
84177
84178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84179   void * jresult ;
84180   Dali::Toolkit::ToggleButton result;
84181
84182   {
84183     try {
84184       result = Dali::Toolkit::ToggleButton::New();
84185     } catch (std::out_of_range& e) {
84186       {
84187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84188       };
84189     } catch (std::exception& e) {
84190       {
84191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84196       };
84197     }
84198   }
84199   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84205   void * jresult ;
84206   Dali::BaseHandle arg1 ;
84207   Dali::BaseHandle *argp1 ;
84208   Dali::Toolkit::ToggleButton result;
84209
84210   argp1 = (Dali::BaseHandle *)jarg1;
84211   if (!argp1) {
84212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84213     return 0;
84214   }
84215   arg1 = *argp1;
84216   {
84217     try {
84218       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84219     } catch (std::out_of_range& e) {
84220       {
84221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84222       };
84223     } catch (std::exception& e) {
84224       {
84225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (...) {
84228       {
84229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84230       };
84231     }
84232   }
84233   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84234   return jresult;
84235 }
84236
84237
84238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84239   void * jresult ;
84240   Dali::Toolkit::Visual::Base *result = 0 ;
84241
84242   {
84243     try {
84244       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84245     } catch (std::out_of_range& e) {
84246       {
84247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (std::exception& e) {
84250       {
84251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84252       };
84253     } catch (...) {
84254       {
84255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84256       };
84257     }
84258   }
84259   jresult = (void *)result;
84260   return jresult;
84261 }
84262
84263
84264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84265   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84266
84267   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84268   {
84269     try {
84270       delete arg1;
84271     } catch (std::out_of_range& e) {
84272       {
84273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84274       };
84275     } catch (std::exception& e) {
84276       {
84277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84278       };
84279     } catch (...) {
84280       {
84281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84282       };
84283     }
84284   }
84285 }
84286
84287
84288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84289   void * jresult ;
84290   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84291   Dali::Toolkit::Visual::Base *result = 0 ;
84292
84293   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84294   if (!arg1) {
84295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84296     return 0;
84297   }
84298   {
84299     try {
84300       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84301     } catch (std::out_of_range& e) {
84302       {
84303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84304       };
84305     } catch (std::exception& e) {
84306       {
84307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84308       };
84309     } catch (...) {
84310       {
84311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84312       };
84313     }
84314   }
84315   jresult = (void *)result;
84316   return jresult;
84317 }
84318
84319
84320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84321   void * jresult ;
84322   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84323   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84324   Dali::Toolkit::Visual::Base *result = 0 ;
84325
84326   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84327   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84328   if (!arg2) {
84329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84330     return 0;
84331   }
84332   {
84333     try {
84334       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84335     } catch (std::out_of_range& e) {
84336       {
84337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84338       };
84339     } catch (std::exception& e) {
84340       {
84341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84342       };
84343     } catch (...) {
84344       {
84345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84346       };
84347     }
84348   }
84349   jresult = (void *)result;
84350   return jresult;
84351 }
84352
84353
84354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84355   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84356   std::string *arg2 = 0 ;
84357
84358   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84359   if (!jarg2) {
84360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84361     return ;
84362   }
84363   std::string arg2_str(jarg2);
84364   arg2 = &arg2_str;
84365   {
84366     try {
84367       (arg1)->SetName((std::string const &)*arg2);
84368     } catch (std::out_of_range& e) {
84369       {
84370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84371       };
84372     } catch (std::exception& e) {
84373       {
84374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84375       };
84376     } catch (...) {
84377       {
84378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84379       };
84380     }
84381   }
84382
84383   //argout typemap for const std::string&
84384
84385 }
84386
84387
84388 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84389   char * jresult ;
84390   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84391   std::string *result = 0 ;
84392
84393   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84394   {
84395     try {
84396       result = (std::string *) &(arg1)->GetName();
84397     } catch (std::out_of_range& e) {
84398       {
84399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84400       };
84401     } catch (std::exception& e) {
84402       {
84403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84404       };
84405     } catch (...) {
84406       {
84407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84408       };
84409     }
84410   }
84411   jresult = SWIG_csharp_string_callback(result->c_str());
84412   return jresult;
84413 }
84414
84415
84416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84417   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84418   Dali::Property::Map *arg2 = 0 ;
84419   Dali::Size arg3 ;
84420   Dali::Size *argp3 ;
84421
84422   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84423   arg2 = (Dali::Property::Map *)jarg2;
84424   if (!arg2) {
84425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84426     return ;
84427   }
84428   argp3 = (Dali::Size *)jarg3;
84429   if (!argp3) {
84430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84431     return ;
84432   }
84433   arg3 = *argp3;
84434   {
84435     try {
84436       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84437     } catch (std::out_of_range& e) {
84438       {
84439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84440       };
84441     } catch (std::exception& e) {
84442       {
84443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84444       };
84445     } catch (...) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84448       };
84449     }
84450   }
84451 }
84452
84453
84454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84455   float jresult ;
84456   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84457   float arg2 ;
84458   float result;
84459
84460   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84461   arg2 = (float)jarg2;
84462   {
84463     try {
84464       result = (float)(arg1)->GetHeightForWidth(arg2);
84465     } catch (std::out_of_range& e) {
84466       {
84467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84468       };
84469     } catch (std::exception& e) {
84470       {
84471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (...) {
84474       {
84475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84476       };
84477     }
84478   }
84479   jresult = result;
84480   return jresult;
84481 }
84482
84483
84484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84485   float jresult ;
84486   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84487   float arg2 ;
84488   float result;
84489
84490   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84491   arg2 = (float)jarg2;
84492   {
84493     try {
84494       result = (float)(arg1)->GetWidthForHeight(arg2);
84495     } catch (std::out_of_range& e) {
84496       {
84497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (std::exception& e) {
84500       {
84501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (...) {
84504       {
84505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84506       };
84507     }
84508   }
84509   jresult = result;
84510   return jresult;
84511 }
84512
84513
84514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84515   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84516   Dali::Vector2 *arg2 = 0 ;
84517
84518   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84519   arg2 = (Dali::Vector2 *)jarg2;
84520   if (!arg2) {
84521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84522     return ;
84523   }
84524   {
84525     try {
84526       (arg1)->GetNaturalSize(*arg2);
84527     } catch (std::out_of_range& e) {
84528       {
84529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84530       };
84531     } catch (std::exception& e) {
84532       {
84533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84534       };
84535     } catch (...) {
84536       {
84537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84538       };
84539     }
84540   }
84541 }
84542
84543
84544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84545   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84546   float arg2 ;
84547
84548   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84549   arg2 = (float)jarg2;
84550   {
84551     try {
84552       (arg1)->SetDepthIndex(arg2);
84553     } catch (std::out_of_range& e) {
84554       {
84555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84556       };
84557     } catch (std::exception& e) {
84558       {
84559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84560       };
84561     } catch (...) {
84562       {
84563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84564       };
84565     }
84566   }
84567 }
84568
84569
84570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84571   float jresult ;
84572   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84573   float result;
84574
84575   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84576   {
84577     try {
84578       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84579     } catch (std::out_of_range& e) {
84580       {
84581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (std::exception& e) {
84584       {
84585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (...) {
84588       {
84589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84590       };
84591     }
84592   }
84593   jresult = result;
84594   return jresult;
84595 }
84596
84597
84598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84599   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84600   Dali::Property::Map *arg2 = 0 ;
84601
84602   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84603   arg2 = (Dali::Property::Map *)jarg2;
84604   if (!arg2) {
84605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84606     return ;
84607   }
84608   {
84609     try {
84610       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84611     } catch (std::out_of_range& e) {
84612       {
84613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84614       };
84615     } catch (std::exception& e) {
84616       {
84617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84622       };
84623     }
84624   }
84625 }
84626
84627
84628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84629   void * jresult ;
84630   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84631   Dali::Toolkit::Visual::Base *result = 0 ;
84632
84633   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84634   {
84635     try {
84636       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (...) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84648       };
84649     }
84650   }
84651   jresult = (void *)result;
84652   return jresult;
84653 }
84654
84655
84656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84657   void * jresult ;
84658   Dali::Toolkit::VisualFactory result;
84659
84660   {
84661     try {
84662       result = Dali::Toolkit::VisualFactory::Get();
84663     } catch (std::out_of_range& e) {
84664       {
84665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (std::exception& e) {
84668       {
84669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (...) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84674       };
84675     }
84676   }
84677   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84683   void * jresult ;
84684   Dali::Toolkit::VisualFactory *result = 0 ;
84685
84686   {
84687     try {
84688       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84689     } catch (std::out_of_range& e) {
84690       {
84691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84692       };
84693     } catch (std::exception& e) {
84694       {
84695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84696       };
84697     } catch (...) {
84698       {
84699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84700       };
84701     }
84702   }
84703   jresult = (void *)result;
84704   return jresult;
84705 }
84706
84707
84708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84709   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84710
84711   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84712   {
84713     try {
84714       delete arg1;
84715     } catch (std::out_of_range& e) {
84716       {
84717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84718       };
84719     } catch (std::exception& e) {
84720       {
84721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84726       };
84727     }
84728   }
84729 }
84730
84731
84732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84733   void * jresult ;
84734   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84735   Dali::Toolkit::VisualFactory *result = 0 ;
84736
84737   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84738   if (!arg1) {
84739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84740     return 0;
84741   }
84742   {
84743     try {
84744       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84756       };
84757     }
84758   }
84759   jresult = (void *)result;
84760   return jresult;
84761 }
84762
84763
84764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84765   void * jresult ;
84766   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84767   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84768   Dali::Toolkit::VisualFactory *result = 0 ;
84769
84770   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84771   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84772   if (!arg2) {
84773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84774     return 0;
84775   }
84776   {
84777     try {
84778       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84779     } catch (std::out_of_range& e) {
84780       {
84781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84782       };
84783     } catch (std::exception& e) {
84784       {
84785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84786       };
84787     } catch (...) {
84788       {
84789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84790       };
84791     }
84792   }
84793   jresult = (void *)result;
84794   return jresult;
84795 }
84796
84797
84798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84799   void * jresult ;
84800   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84801   Dali::Property::Map *arg2 = 0 ;
84802   Dali::Toolkit::Visual::Base result;
84803
84804   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84805   arg2 = (Dali::Property::Map *)jarg2;
84806   if (!arg2) {
84807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84808     return 0;
84809   }
84810   {
84811     try {
84812       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84824       };
84825     }
84826   }
84827   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84833   void * jresult ;
84834   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84835   Dali::Image *arg2 = 0 ;
84836   Dali::Toolkit::Visual::Base result;
84837
84838   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84839   arg2 = (Dali::Image *)jarg2;
84840   if (!arg2) {
84841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84842     return 0;
84843   }
84844   {
84845     try {
84846       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84847     } catch (std::out_of_range& e) {
84848       {
84849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84850       };
84851     } catch (std::exception& e) {
84852       {
84853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84854       };
84855     } catch (...) {
84856       {
84857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84858       };
84859     }
84860   }
84861   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84862   return jresult;
84863 }
84864
84865
84866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84867   void * jresult ;
84868   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84869   std::string *arg2 = 0 ;
84870   Dali::ImageDimensions arg3 ;
84871   Dali::ImageDimensions *argp3 ;
84872   Dali::Toolkit::Visual::Base result;
84873
84874   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84875   if (!jarg2) {
84876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84877     return 0;
84878   }
84879   std::string arg2_str(jarg2);
84880   arg2 = &arg2_str;
84881   argp3 = (Dali::ImageDimensions *)jarg3;
84882   if (!argp3) {
84883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84884     return 0;
84885   }
84886   arg3 = *argp3;
84887   {
84888     try {
84889       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84890     } catch (std::out_of_range& e) {
84891       {
84892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84893       };
84894     } catch (std::exception& e) {
84895       {
84896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84897       };
84898     } catch (...) {
84899       {
84900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84901       };
84902     }
84903   }
84904   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84905
84906   //argout typemap for const std::string&
84907
84908   return jresult;
84909 }
84910
84911
84912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84913   void * jresult ;
84914   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84915
84916   {
84917     try {
84918       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84926       };
84927     } catch (...) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84930       };
84931     }
84932   }
84933   jresult = (void *)result;
84934   return jresult;
84935 }
84936
84937
84938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84939   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84940
84941   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84942   {
84943     try {
84944       delete arg1;
84945     } catch (std::out_of_range& e) {
84946       {
84947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84948       };
84949     } catch (std::exception& e) {
84950       {
84951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84952       };
84953     } catch (...) {
84954       {
84955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84956       };
84957     }
84958   }
84959 }
84960
84961
84962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84963   void * jresult ;
84964   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84965   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84966
84967   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84968   if (!arg1) {
84969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84970     return 0;
84971   }
84972   {
84973     try {
84974       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84975     } catch (std::out_of_range& e) {
84976       {
84977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (std::exception& e) {
84980       {
84981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84982       };
84983     } catch (...) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84986       };
84987     }
84988   }
84989   jresult = (void *)result;
84990   return jresult;
84991 }
84992
84993
84994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
84995   void * jresult ;
84996   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84997   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
84998   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84999
85000   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85001   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85002   if (!arg2) {
85003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85004     return 0;
85005   }
85006   {
85007     try {
85008       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (...) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85020       };
85021     }
85022   }
85023   jresult = (void *)result;
85024   return jresult;
85025 }
85026
85027
85028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85029   void * jresult ;
85030   Dali::Toolkit::AsyncImageLoader result;
85031
85032   {
85033     try {
85034       result = Dali::Toolkit::AsyncImageLoader::New();
85035     } catch (std::out_of_range& e) {
85036       {
85037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85038       };
85039     } catch (std::exception& e) {
85040       {
85041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85042       };
85043     } catch (...) {
85044       {
85045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85046       };
85047     }
85048   }
85049   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85050   return jresult;
85051 }
85052
85053
85054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85055   void * jresult ;
85056   Dali::BaseHandle arg1 ;
85057   Dali::BaseHandle *argp1 ;
85058   Dali::Toolkit::AsyncImageLoader result;
85059
85060   argp1 = (Dali::BaseHandle *)jarg1;
85061   if (!argp1) {
85062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85063     return 0;
85064   }
85065   arg1 = *argp1;
85066   {
85067     try {
85068       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85069     } catch (std::out_of_range& e) {
85070       {
85071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85072       };
85073     } catch (std::exception& e) {
85074       {
85075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85076       };
85077     } catch (...) {
85078       {
85079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85080       };
85081     }
85082   }
85083   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85084   return jresult;
85085 }
85086
85087
85088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85089   unsigned int jresult ;
85090   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85091   std::string *arg2 = 0 ;
85092   uint32_t result;
85093
85094   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85095   if (!jarg2) {
85096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85097     return 0;
85098   }
85099   std::string arg2_str(jarg2);
85100   arg2 = &arg2_str;
85101   {
85102     try {
85103       result = (arg1)->Load((std::string const &)*arg2);
85104     } catch (std::out_of_range& e) {
85105       {
85106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85107       };
85108     } catch (std::exception& e) {
85109       {
85110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85111       };
85112     } catch (...) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85115       };
85116     }
85117   }
85118   jresult = result;
85119
85120   //argout typemap for const std::string&
85121
85122   return jresult;
85123 }
85124
85125
85126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85127   unsigned int jresult ;
85128   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85129   std::string *arg2 = 0 ;
85130   Dali::ImageDimensions arg3 ;
85131   Dali::ImageDimensions *argp3 ;
85132   uint32_t result;
85133
85134   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85135   if (!jarg2) {
85136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85137     return 0;
85138   }
85139   std::string arg2_str(jarg2);
85140   arg2 = &arg2_str;
85141   argp3 = (Dali::ImageDimensions *)jarg3;
85142   if (!argp3) {
85143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85144     return 0;
85145   }
85146   arg3 = *argp3;
85147   {
85148     try {
85149       result = (arg1)->Load((std::string const &)*arg2,arg3);
85150     } catch (std::out_of_range& e) {
85151       {
85152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85153       };
85154     } catch (std::exception& e) {
85155       {
85156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85157       };
85158     } catch (...) {
85159       {
85160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85161       };
85162     }
85163   }
85164   jresult = result;
85165
85166   //argout typemap for const std::string&
85167
85168   return jresult;
85169 }
85170
85171
85172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85173   unsigned int jresult ;
85174   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85175   std::string *arg2 = 0 ;
85176   Dali::ImageDimensions arg3 ;
85177   Dali::FittingMode::Type arg4 ;
85178   Dali::SamplingMode::Type arg5 ;
85179   bool arg6 ;
85180   Dali::ImageDimensions *argp3 ;
85181   uint32_t result;
85182
85183   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85184   if (!jarg2) {
85185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85186     return 0;
85187   }
85188   std::string arg2_str(jarg2);
85189   arg2 = &arg2_str;
85190   argp3 = (Dali::ImageDimensions *)jarg3;
85191   if (!argp3) {
85192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85193     return 0;
85194   }
85195   arg3 = *argp3;
85196   arg4 = (Dali::FittingMode::Type)jarg4;
85197   arg5 = (Dali::SamplingMode::Type)jarg5;
85198   arg6 = jarg6 ? true : false;
85199   {
85200     try {
85201       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85202     } catch (std::out_of_range& e) {
85203       {
85204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (std::exception& e) {
85207       {
85208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (...) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85213       };
85214     }
85215   }
85216   jresult = result;
85217
85218   //argout typemap for const std::string&
85219
85220   return jresult;
85221 }
85222
85223
85224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85225   unsigned int jresult ;
85226   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85227   uint32_t arg2 ;
85228   bool result;
85229
85230   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85231   arg2 = (uint32_t)jarg2;
85232   {
85233     try {
85234       result = (bool)(arg1)->Cancel(arg2);
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85242       };
85243     } catch (...) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85246       };
85247     }
85248   }
85249   jresult = result;
85250   return jresult;
85251 }
85252
85253
85254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85255   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85256
85257   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85258   {
85259     try {
85260       (arg1)->CancelAll();
85261     } catch (std::out_of_range& e) {
85262       {
85263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85264       };
85265     } catch (std::exception& e) {
85266       {
85267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85268       };
85269     } catch (...) {
85270       {
85271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85272       };
85273     }
85274   }
85275 }
85276
85277
85278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85279   void * jresult ;
85280   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85281   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85282
85283   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85284   {
85285     try {
85286       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85287     } catch (std::out_of_range& e) {
85288       {
85289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85290       };
85291     } catch (std::exception& e) {
85292       {
85293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (...) {
85296       {
85297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85298       };
85299     }
85300   }
85301   jresult = (void *)result;
85302   return jresult;
85303 }
85304
85305
85306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85307   void * jresult ;
85308   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85309   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85310
85311   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85312   {
85313     try {
85314       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85315     } catch (std::out_of_range& e) {
85316       {
85317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85318       };
85319     } catch (std::exception& e) {
85320       {
85321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (...) {
85324       {
85325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85326       };
85327     }
85328   }
85329   jresult = (void *)result;
85330   return jresult;
85331 }
85332
85333
85334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85335   void * jresult ;
85336   std::string *arg1 = 0 ;
85337   Dali::PixelData result;
85338
85339   if (!jarg1) {
85340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85341     return 0;
85342   }
85343   std::string arg1_str(jarg1);
85344   arg1 = &arg1_str;
85345   {
85346     try {
85347       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85348     } catch (std::out_of_range& e) {
85349       {
85350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85351       };
85352     } catch (std::exception& e) {
85353       {
85354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85355       };
85356     } catch (...) {
85357       {
85358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85359       };
85360     }
85361   }
85362   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85363
85364   //argout typemap for const std::string&
85365
85366   return jresult;
85367 }
85368
85369
85370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85371   void * jresult ;
85372   std::string *arg1 = 0 ;
85373   Dali::ImageDimensions arg2 ;
85374   Dali::ImageDimensions *argp2 ;
85375   Dali::PixelData result;
85376
85377   if (!jarg1) {
85378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85379     return 0;
85380   }
85381   std::string arg1_str(jarg1);
85382   arg1 = &arg1_str;
85383   argp2 = (Dali::ImageDimensions *)jarg2;
85384   if (!argp2) {
85385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85386     return 0;
85387   }
85388   arg2 = *argp2;
85389   {
85390     try {
85391       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85392     } catch (std::out_of_range& e) {
85393       {
85394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85395       };
85396     } catch (std::exception& e) {
85397       {
85398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85399       };
85400     } catch (...) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85403       };
85404     }
85405   }
85406   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85407
85408   //argout typemap for const std::string&
85409
85410   return jresult;
85411 }
85412
85413
85414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85415   void * jresult ;
85416   std::string *arg1 = 0 ;
85417   Dali::ImageDimensions arg2 ;
85418   Dali::FittingMode::Type arg3 ;
85419   Dali::SamplingMode::Type arg4 ;
85420   bool arg5 ;
85421   Dali::ImageDimensions *argp2 ;
85422   Dali::PixelData result;
85423
85424   if (!jarg1) {
85425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85426     return 0;
85427   }
85428   std::string arg1_str(jarg1);
85429   arg1 = &arg1_str;
85430   argp2 = (Dali::ImageDimensions *)jarg2;
85431   if (!argp2) {
85432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85433     return 0;
85434   }
85435   arg2 = *argp2;
85436   arg3 = (Dali::FittingMode::Type)jarg3;
85437   arg4 = (Dali::SamplingMode::Type)jarg4;
85438   arg5 = jarg5 ? true : false;
85439   {
85440     try {
85441       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85442     } catch (std::out_of_range& e) {
85443       {
85444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85445       };
85446     } catch (std::exception& e) {
85447       {
85448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85449       };
85450     } catch (...) {
85451       {
85452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85453       };
85454     }
85455   }
85456   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85457
85458   //argout typemap for const std::string&
85459
85460   return jresult;
85461 }
85462
85463
85464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85465   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85466
85467   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85468   {
85469     try {
85470       delete arg1;
85471     } catch (std::out_of_range& e) {
85472       {
85473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85474       };
85475     } catch (std::exception& e) {
85476       {
85477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85478       };
85479     } catch (...) {
85480       {
85481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85482       };
85483     }
85484   }
85485 }
85486
85487
85488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85489   void * jresult ;
85490   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85491   Dali::Actor arg2 ;
85492   Dali::Actor arg3 ;
85493   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85494   Dali::Actor *argp2 ;
85495   Dali::Actor *argp3 ;
85496   Dali::Actor result;
85497
85498   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85499   argp2 = (Dali::Actor *)jarg2;
85500   if (!argp2) {
85501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85502     return 0;
85503   }
85504   arg2 = *argp2;
85505   argp3 = (Dali::Actor *)jarg3;
85506   if (!argp3) {
85507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85508     return 0;
85509   }
85510   arg3 = *argp3;
85511   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85512   {
85513     try {
85514       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85515     } catch (std::out_of_range& e) {
85516       {
85517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85518       };
85519     } catch (std::exception& e) {
85520       {
85521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85522       };
85523     } catch (...) {
85524       {
85525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85526       };
85527     }
85528   }
85529   jresult = new Dali::Actor((const Dali::Actor &)result);
85530   return jresult;
85531 }
85532
85533
85534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85535   void * jresult ;
85536   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85537
85538   {
85539     try {
85540       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85541     } catch (std::out_of_range& e) {
85542       {
85543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85544       };
85545     } catch (std::exception& e) {
85546       {
85547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85548       };
85549     } catch (...) {
85550       {
85551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85552       };
85553     }
85554   }
85555   jresult = (void *)result;
85556   return jresult;
85557 }
85558
85559
85560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85561   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85562   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85563   if (director) {
85564     director->swig_connect_director(callback0);
85565   }
85566 }
85567
85568
85569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85570   KeyboardFocusManager arg1 ;
85571   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85572   KeyboardFocusManager *argp1 ;
85573
85574   argp1 = (KeyboardFocusManager *)jarg1;
85575   if (!argp1) {
85576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85577     return ;
85578   }
85579   arg1 = *argp1;
85580   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85581   if (!arg2) {
85582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85583     return ;
85584   }
85585   {
85586     try {
85587       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85588     } catch (std::out_of_range& e) {
85589       {
85590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85591       };
85592     } catch (std::exception& e) {
85593       {
85594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85599       };
85600     }
85601   }
85602 }
85603
85604
85605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85607
85608   arg1 = (std::vector< unsigned int > *)jarg1;
85609   {
85610     try {
85611       (arg1)->clear();
85612     } catch (std::out_of_range& e) {
85613       {
85614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85615       };
85616     } catch (std::exception& e) {
85617       {
85618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85619       };
85620     } catch (...) {
85621       {
85622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85623       };
85624     }
85625   }
85626 }
85627
85628
85629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85630   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85631   unsigned int *arg2 = 0 ;
85632   unsigned int temp2 ;
85633
85634   arg1 = (std::vector< unsigned int > *)jarg1;
85635   temp2 = (unsigned int)jarg2;
85636   arg2 = &temp2;
85637   {
85638     try {
85639       (arg1)->push_back((unsigned int const &)*arg2);
85640     } catch (std::out_of_range& e) {
85641       {
85642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85643       };
85644     } catch (std::exception& e) {
85645       {
85646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85647       };
85648     } catch (...) {
85649       {
85650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85651       };
85652     }
85653   }
85654 }
85655
85656
85657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85658   unsigned long jresult ;
85659   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85660   std::vector< unsigned int >::size_type result;
85661
85662   arg1 = (std::vector< unsigned int > *)jarg1;
85663   {
85664     try {
85665       result = ((std::vector< unsigned int > const *)arg1)->size();
85666     } catch (std::out_of_range& e) {
85667       {
85668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85669       };
85670     } catch (std::exception& e) {
85671       {
85672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85673       };
85674     } catch (...) {
85675       {
85676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85677       };
85678     }
85679   }
85680   jresult = (unsigned long)result;
85681   return jresult;
85682 }
85683
85684
85685 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85686   unsigned long jresult ;
85687   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85688   std::vector< unsigned int >::size_type result;
85689
85690   arg1 = (std::vector< unsigned int > *)jarg1;
85691   {
85692     try {
85693       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85694     } catch (std::out_of_range& e) {
85695       {
85696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (std::exception& e) {
85699       {
85700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (...) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85705       };
85706     }
85707   }
85708   jresult = (unsigned long)result;
85709   return jresult;
85710 }
85711
85712
85713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85714   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85715   std::vector< unsigned int >::size_type arg2 ;
85716
85717   arg1 = (std::vector< unsigned int > *)jarg1;
85718   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85719   {
85720     try {
85721       (arg1)->reserve(arg2);
85722     } catch (std::out_of_range& e) {
85723       {
85724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85725       };
85726     } catch (std::exception& e) {
85727       {
85728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85729       };
85730     } catch (...) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85733       };
85734     }
85735   }
85736 }
85737
85738
85739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85740   void * jresult ;
85741   std::vector< unsigned int > *result = 0 ;
85742
85743   {
85744     try {
85745       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85746     } catch (std::out_of_range& e) {
85747       {
85748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85749       };
85750     } catch (std::exception& e) {
85751       {
85752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85753       };
85754     } catch (...) {
85755       {
85756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85757       };
85758     }
85759   }
85760   jresult = (void *)result;
85761   return jresult;
85762 }
85763
85764
85765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85766   void * jresult ;
85767   std::vector< unsigned int > *arg1 = 0 ;
85768   std::vector< unsigned int > *result = 0 ;
85769
85770   arg1 = (std::vector< unsigned int > *)jarg1;
85771   if (!arg1) {
85772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85773     return 0;
85774   }
85775   {
85776     try {
85777       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85778     } catch (std::out_of_range& e) {
85779       {
85780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (std::exception& e) {
85783       {
85784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (...) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85789       };
85790     }
85791   }
85792   jresult = (void *)result;
85793   return jresult;
85794 }
85795
85796
85797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85798   void * jresult ;
85799   int arg1 ;
85800   std::vector< unsigned int > *result = 0 ;
85801
85802   arg1 = (int)jarg1;
85803   {
85804     try {
85805       try {
85806         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85807       }
85808       catch(std::out_of_range &_e) {
85809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85810         return 0;
85811       }
85812
85813     } catch (std::out_of_range& e) {
85814       {
85815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85816       };
85817     } catch (std::exception& e) {
85818       {
85819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85820       };
85821     } catch (...) {
85822       {
85823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85824       };
85825     }
85826   }
85827   jresult = (void *)result;
85828   return jresult;
85829 }
85830
85831
85832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85833   unsigned int jresult ;
85834   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85835   int arg2 ;
85836   unsigned int result;
85837
85838   arg1 = (std::vector< unsigned int > *)jarg1;
85839   arg2 = (int)jarg2;
85840   {
85841     try {
85842       try {
85843         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85844       }
85845       catch(std::out_of_range &_e) {
85846         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85847         return 0;
85848       }
85849
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864   jresult = result;
85865   return jresult;
85866 }
85867
85868
85869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85870   unsigned int jresult ;
85871   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85872   int arg2 ;
85873   unsigned int *result = 0 ;
85874
85875   arg1 = (std::vector< unsigned int > *)jarg1;
85876   arg2 = (int)jarg2;
85877   {
85878     try {
85879       try {
85880         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85881       }
85882       catch(std::out_of_range &_e) {
85883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85884         return 0;
85885       }
85886
85887     } catch (std::out_of_range& e) {
85888       {
85889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (std::exception& e) {
85892       {
85893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901   jresult = *result;
85902   return jresult;
85903 }
85904
85905
85906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85907   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85908   int arg2 ;
85909   unsigned int *arg3 = 0 ;
85910   unsigned int temp3 ;
85911
85912   arg1 = (std::vector< unsigned int > *)jarg1;
85913   arg2 = (int)jarg2;
85914   temp3 = (unsigned int)jarg3;
85915   arg3 = &temp3;
85916   {
85917     try {
85918       try {
85919         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85920       }
85921       catch(std::out_of_range &_e) {
85922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85923         return ;
85924       }
85925
85926     } catch (std::out_of_range& e) {
85927       {
85928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85929       };
85930     } catch (std::exception& e) {
85931       {
85932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85933       };
85934     } catch (...) {
85935       {
85936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85937       };
85938     }
85939   }
85940 }
85941
85942
85943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85944   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85945   std::vector< unsigned int > *arg2 = 0 ;
85946
85947   arg1 = (std::vector< unsigned int > *)jarg1;
85948   arg2 = (std::vector< unsigned int > *)jarg2;
85949   if (!arg2) {
85950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85951     return ;
85952   }
85953   {
85954     try {
85955       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85963       };
85964     } catch (...) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85967       };
85968     }
85969   }
85970 }
85971
85972
85973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85974   void * jresult ;
85975   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85976   int arg2 ;
85977   int arg3 ;
85978   std::vector< unsigned int > *result = 0 ;
85979
85980   arg1 = (std::vector< unsigned int > *)jarg1;
85981   arg2 = (int)jarg2;
85982   arg3 = (int)jarg3;
85983   {
85984     try {
85985       try {
85986         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85987       }
85988       catch(std::out_of_range &_e) {
85989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85990         return 0;
85991       }
85992       catch(std::invalid_argument &_e) {
85993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85994         return 0;
85995       }
85996
85997     } catch (std::out_of_range& e) {
85998       {
85999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86000       };
86001     } catch (std::exception& e) {
86002       {
86003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (...) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86008       };
86009     }
86010   }
86011   jresult = (void *)result;
86012   return jresult;
86013 }
86014
86015
86016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86017   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86018   int arg2 ;
86019   unsigned int *arg3 = 0 ;
86020   unsigned int temp3 ;
86021
86022   arg1 = (std::vector< unsigned int > *)jarg1;
86023   arg2 = (int)jarg2;
86024   temp3 = (unsigned int)jarg3;
86025   arg3 = &temp3;
86026   {
86027     try {
86028       try {
86029         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86030       }
86031       catch(std::out_of_range &_e) {
86032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86033         return ;
86034       }
86035
86036     } catch (std::out_of_range& e) {
86037       {
86038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86039       };
86040     } catch (std::exception& e) {
86041       {
86042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86043       };
86044     } catch (...) {
86045       {
86046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86047       };
86048     }
86049   }
86050 }
86051
86052
86053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86054   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86055   int arg2 ;
86056   std::vector< unsigned int > *arg3 = 0 ;
86057
86058   arg1 = (std::vector< unsigned int > *)jarg1;
86059   arg2 = (int)jarg2;
86060   arg3 = (std::vector< unsigned int > *)jarg3;
86061   if (!arg3) {
86062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86063     return ;
86064   }
86065   {
86066     try {
86067       try {
86068         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86069       }
86070       catch(std::out_of_range &_e) {
86071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86072         return ;
86073       }
86074
86075     } catch (std::out_of_range& e) {
86076       {
86077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86078       };
86079     } catch (std::exception& e) {
86080       {
86081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86082       };
86083     } catch (...) {
86084       {
86085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86086       };
86087     }
86088   }
86089 }
86090
86091
86092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86093   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86094   int arg2 ;
86095
86096   arg1 = (std::vector< unsigned int > *)jarg1;
86097   arg2 = (int)jarg2;
86098   {
86099     try {
86100       try {
86101         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86102       }
86103       catch(std::out_of_range &_e) {
86104         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86105         return ;
86106       }
86107
86108     } catch (std::out_of_range& e) {
86109       {
86110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86111       };
86112     } catch (std::exception& e) {
86113       {
86114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86115       };
86116     } catch (...) {
86117       {
86118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86119       };
86120     }
86121   }
86122 }
86123
86124
86125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86126   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86127   int arg2 ;
86128   int arg3 ;
86129
86130   arg1 = (std::vector< unsigned int > *)jarg1;
86131   arg2 = (int)jarg2;
86132   arg3 = (int)jarg3;
86133   {
86134     try {
86135       try {
86136         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86137       }
86138       catch(std::out_of_range &_e) {
86139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86140         return ;
86141       }
86142       catch(std::invalid_argument &_e) {
86143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86144         return ;
86145       }
86146
86147     } catch (std::out_of_range& e) {
86148       {
86149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86150       };
86151     } catch (std::exception& e) {
86152       {
86153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86154       };
86155     } catch (...) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86158       };
86159     }
86160   }
86161 }
86162
86163
86164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86165   void * jresult ;
86166   unsigned int *arg1 = 0 ;
86167   int arg2 ;
86168   unsigned int temp1 ;
86169   std::vector< unsigned int > *result = 0 ;
86170
86171   temp1 = (unsigned int)jarg1;
86172   arg1 = &temp1;
86173   arg2 = (int)jarg2;
86174   {
86175     try {
86176       try {
86177         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86178       }
86179       catch(std::out_of_range &_e) {
86180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86181         return 0;
86182       }
86183
86184     } catch (std::out_of_range& e) {
86185       {
86186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (std::exception& e) {
86189       {
86190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86191       };
86192     } catch (...) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86195       };
86196     }
86197   }
86198   jresult = (void *)result;
86199   return jresult;
86200 }
86201
86202
86203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86204   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86205
86206   arg1 = (std::vector< unsigned int > *)jarg1;
86207   {
86208     try {
86209       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86210     } catch (std::out_of_range& e) {
86211       {
86212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86213       };
86214     } catch (std::exception& e) {
86215       {
86216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86217       };
86218     } catch (...) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86221       };
86222     }
86223   }
86224 }
86225
86226
86227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86228   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86229   int arg2 ;
86230   int arg3 ;
86231
86232   arg1 = (std::vector< unsigned int > *)jarg1;
86233   arg2 = (int)jarg2;
86234   arg3 = (int)jarg3;
86235   {
86236     try {
86237       try {
86238         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86239       }
86240       catch(std::out_of_range &_e) {
86241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86242         return ;
86243       }
86244       catch(std::invalid_argument &_e) {
86245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86246         return ;
86247       }
86248
86249     } catch (std::out_of_range& e) {
86250       {
86251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86252       };
86253     } catch (std::exception& e) {
86254       {
86255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86256       };
86257     } catch (...) {
86258       {
86259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86260       };
86261     }
86262   }
86263 }
86264
86265
86266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86267   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86268   int arg2 ;
86269   std::vector< unsigned int > *arg3 = 0 ;
86270
86271   arg1 = (std::vector< unsigned int > *)jarg1;
86272   arg2 = (int)jarg2;
86273   arg3 = (std::vector< unsigned int > *)jarg3;
86274   if (!arg3) {
86275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86276     return ;
86277   }
86278   {
86279     try {
86280       try {
86281         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86282       }
86283       catch(std::out_of_range &_e) {
86284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86285         return ;
86286       }
86287
86288     } catch (std::out_of_range& e) {
86289       {
86290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86291       };
86292     } catch (std::exception& e) {
86293       {
86294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86295       };
86296     } catch (...) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86299       };
86300     }
86301   }
86302 }
86303
86304
86305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86306   unsigned int jresult ;
86307   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86308   unsigned int *arg2 = 0 ;
86309   unsigned int temp2 ;
86310   bool result;
86311
86312   arg1 = (std::vector< unsigned int > *)jarg1;
86313   temp2 = (unsigned int)jarg2;
86314   arg2 = &temp2;
86315   {
86316     try {
86317       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86318     } catch (std::out_of_range& e) {
86319       {
86320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (std::exception& e) {
86323       {
86324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (...) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86329       };
86330     }
86331   }
86332   jresult = result;
86333   return jresult;
86334 }
86335
86336
86337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86338   int jresult ;
86339   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86340   unsigned int *arg2 = 0 ;
86341   unsigned int temp2 ;
86342   int result;
86343
86344   arg1 = (std::vector< unsigned int > *)jarg1;
86345   temp2 = (unsigned int)jarg2;
86346   arg2 = &temp2;
86347   {
86348     try {
86349       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (...) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86361       };
86362     }
86363   }
86364   jresult = result;
86365   return jresult;
86366 }
86367
86368
86369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86370   int jresult ;
86371   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86372   unsigned int *arg2 = 0 ;
86373   unsigned int temp2 ;
86374   int result;
86375
86376   arg1 = (std::vector< unsigned int > *)jarg1;
86377   temp2 = (unsigned int)jarg2;
86378   arg2 = &temp2;
86379   {
86380     try {
86381       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86382     } catch (std::out_of_range& e) {
86383       {
86384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86385       };
86386     } catch (std::exception& e) {
86387       {
86388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86389       };
86390     } catch (...) {
86391       {
86392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86393       };
86394     }
86395   }
86396   jresult = result;
86397   return jresult;
86398 }
86399
86400
86401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86402   unsigned int jresult ;
86403   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86404   unsigned int *arg2 = 0 ;
86405   unsigned int temp2 ;
86406   bool result;
86407
86408   arg1 = (std::vector< unsigned int > *)jarg1;
86409   temp2 = (unsigned int)jarg2;
86410   arg2 = &temp2;
86411   {
86412     try {
86413       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86414     } catch (std::out_of_range& e) {
86415       {
86416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (std::exception& e) {
86419       {
86420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (...) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86425       };
86426     }
86427   }
86428   jresult = result;
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86434   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86435
86436   arg1 = (std::vector< unsigned int > *)jarg1;
86437   {
86438     try {
86439       delete arg1;
86440     } catch (std::out_of_range& e) {
86441       {
86442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86443       };
86444     } catch (std::exception& e) {
86445       {
86446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86447       };
86448     } catch (...) {
86449       {
86450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86451       };
86452     }
86453   }
86454 }
86455
86456
86457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86458   void * jresult ;
86459   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86460
86461   {
86462     try {
86463       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86464     } catch (std::out_of_range& e) {
86465       {
86466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86467       };
86468     } catch (std::exception& e) {
86469       {
86470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86471       };
86472     } catch (...) {
86473       {
86474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86475       };
86476     }
86477   }
86478   jresult = (void *)result;
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86484   void * jresult ;
86485   unsigned int arg1 ;
86486   Dali::Actor arg2 ;
86487   Dali::Actor *argp2 ;
86488   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86489
86490   arg1 = (unsigned int)jarg1;
86491   argp2 = (Dali::Actor *)jarg2;
86492   if (!argp2) {
86493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86494     return 0;
86495   }
86496   arg2 = *argp2;
86497   {
86498     try {
86499       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86500     } catch (std::out_of_range& e) {
86501       {
86502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (std::exception& e) {
86505       {
86506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86507       };
86508     } catch (...) {
86509       {
86510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86511       };
86512     }
86513   }
86514   jresult = (void *)result;
86515   return jresult;
86516 }
86517
86518
86519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86520   void * jresult ;
86521   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86522   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86523
86524   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86525   if (!arg1) {
86526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86527     return 0;
86528   }
86529   {
86530     try {
86531       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86532     } catch (std::out_of_range& e) {
86533       {
86534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (std::exception& e) {
86537       {
86538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86539       };
86540     } catch (...) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86543       };
86544     }
86545   }
86546   jresult = (void *)result;
86547   return jresult;
86548 }
86549
86550
86551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86552   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86553   unsigned int arg2 ;
86554
86555   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86556   arg2 = (unsigned int)jarg2;
86557   if (arg1) (arg1)->first = arg2;
86558 }
86559
86560
86561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86562   unsigned int jresult ;
86563   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86564   unsigned int result;
86565
86566   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86567   result = (unsigned int) ((arg1)->first);
86568   jresult = result;
86569   return jresult;
86570 }
86571
86572
86573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86574   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86575   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86576
86577   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86578   arg2 = (Dali::Actor *)jarg2;
86579   if (arg1) (arg1)->second = *arg2;
86580 }
86581
86582
86583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86584   void * jresult ;
86585   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86586   Dali::Actor *result = 0 ;
86587
86588   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86589   result = (Dali::Actor *)& ((arg1)->second);
86590   jresult = (void *)result;
86591   return jresult;
86592 }
86593
86594
86595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86596   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86597
86598   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86599   {
86600     try {
86601       delete arg1;
86602     } catch (std::out_of_range& e) {
86603       {
86604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86605       };
86606     } catch (std::exception& e) {
86607       {
86608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86609       };
86610     } catch (...) {
86611       {
86612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86613       };
86614     }
86615   }
86616 }
86617
86618
86619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86620   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86621
86622   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86623   {
86624     try {
86625       (arg1)->clear();
86626     } catch (std::out_of_range& e) {
86627       {
86628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86629       };
86630     } catch (std::exception& e) {
86631       {
86632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86633       };
86634     } catch (...) {
86635       {
86636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86637       };
86638     }
86639   }
86640 }
86641
86642
86643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86644   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86645   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86646
86647   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86648   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86649   if (!arg2) {
86650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86651     return ;
86652   }
86653   {
86654     try {
86655       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86656     } catch (std::out_of_range& e) {
86657       {
86658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86659       };
86660     } catch (std::exception& e) {
86661       {
86662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86663       };
86664     } catch (...) {
86665       {
86666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86667       };
86668     }
86669   }
86670 }
86671
86672
86673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86674   unsigned long jresult ;
86675   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86676   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86677
86678   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86679   {
86680     try {
86681       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86682     } catch (std::out_of_range& e) {
86683       {
86684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86685       };
86686     } catch (std::exception& e) {
86687       {
86688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86689       };
86690     } catch (...) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86693       };
86694     }
86695   }
86696   jresult = (unsigned long)result;
86697   return jresult;
86698 }
86699
86700
86701 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86702   unsigned long jresult ;
86703   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86704   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86705
86706   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86707   {
86708     try {
86709       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86710     } catch (std::out_of_range& e) {
86711       {
86712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (std::exception& e) {
86715       {
86716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86717       };
86718     } catch (...) {
86719       {
86720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86721       };
86722     }
86723   }
86724   jresult = (unsigned long)result;
86725   return jresult;
86726 }
86727
86728
86729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86730   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86731   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86732
86733   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86734   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86735   {
86736     try {
86737       (arg1)->reserve(arg2);
86738     } catch (std::out_of_range& e) {
86739       {
86740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86741       };
86742     } catch (std::exception& e) {
86743       {
86744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86745       };
86746     } catch (...) {
86747       {
86748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86749       };
86750     }
86751   }
86752 }
86753
86754
86755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86756   void * jresult ;
86757   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86758
86759   {
86760     try {
86761       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86762     } catch (std::out_of_range& e) {
86763       {
86764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86765       };
86766     } catch (std::exception& e) {
86767       {
86768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86769       };
86770     } catch (...) {
86771       {
86772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86773       };
86774     }
86775   }
86776   jresult = (void *)result;
86777   return jresult;
86778 }
86779
86780
86781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86782   void * jresult ;
86783   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86784   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86785
86786   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86787   if (!arg1) {
86788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86789     return 0;
86790   }
86791   {
86792     try {
86793       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);
86794     } catch (std::out_of_range& e) {
86795       {
86796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86797       };
86798     } catch (std::exception& e) {
86799       {
86800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86801       };
86802     } catch (...) {
86803       {
86804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86805       };
86806     }
86807   }
86808   jresult = (void *)result;
86809   return jresult;
86810 }
86811
86812
86813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86814   void * jresult ;
86815   int arg1 ;
86816   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86817
86818   arg1 = (int)jarg1;
86819   {
86820     try {
86821       try {
86822         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);
86823       }
86824       catch(std::out_of_range &_e) {
86825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86826         return 0;
86827       }
86828
86829     } catch (std::out_of_range& e) {
86830       {
86831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86832       };
86833     } catch (std::exception& e) {
86834       {
86835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86836       };
86837     } catch (...) {
86838       {
86839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86840       };
86841     }
86842   }
86843   jresult = (void *)result;
86844   return jresult;
86845 }
86846
86847
86848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86849   void * jresult ;
86850   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86851   int arg2 ;
86852   std::pair< unsigned int,Dali::Actor > result;
86853
86854   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86855   arg2 = (int)jarg2;
86856   {
86857     try {
86858       try {
86859         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86860       }
86861       catch(std::out_of_range &_e) {
86862         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86863         return 0;
86864       }
86865
86866     } catch (std::out_of_range& e) {
86867       {
86868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86869       };
86870     } catch (std::exception& e) {
86871       {
86872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86873       };
86874     } catch (...) {
86875       {
86876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86877       };
86878     }
86879   }
86880   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86881   return jresult;
86882 }
86883
86884
86885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86886   void * jresult ;
86887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86888   int arg2 ;
86889   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86890
86891   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86892   arg2 = (int)jarg2;
86893   {
86894     try {
86895       try {
86896         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86897       }
86898       catch(std::out_of_range &_e) {
86899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86900         return 0;
86901       }
86902
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (...) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86914       };
86915     }
86916   }
86917   jresult = (void *)result;
86918   return jresult;
86919 }
86920
86921
86922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86923   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86924   int arg2 ;
86925   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86926
86927   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86928   arg2 = (int)jarg2;
86929   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86930   if (!arg3) {
86931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86932     return ;
86933   }
86934   {
86935     try {
86936       try {
86937         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);
86938       }
86939       catch(std::out_of_range &_e) {
86940         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86941         return ;
86942       }
86943
86944     } catch (std::out_of_range& e) {
86945       {
86946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86947       };
86948     } catch (std::exception& e) {
86949       {
86950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86951       };
86952     } catch (...) {
86953       {
86954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86955       };
86956     }
86957   }
86958 }
86959
86960
86961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86962   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86963   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86964
86965   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86966   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86967   if (!arg2) {
86968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86969     return ;
86970   }
86971   {
86972     try {
86973       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);
86974     } catch (std::out_of_range& e) {
86975       {
86976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86977       };
86978     } catch (std::exception& e) {
86979       {
86980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86981       };
86982     } catch (...) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86985       };
86986     }
86987   }
86988 }
86989
86990
86991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86992   void * jresult ;
86993   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86994   int arg2 ;
86995   int arg3 ;
86996   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86997
86998   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86999   arg2 = (int)jarg2;
87000   arg3 = (int)jarg3;
87001   {
87002     try {
87003       try {
87004         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);
87005       }
87006       catch(std::out_of_range &_e) {
87007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87008         return 0;
87009       }
87010       catch(std::invalid_argument &_e) {
87011         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87012         return 0;
87013       }
87014
87015     } catch (std::out_of_range& e) {
87016       {
87017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87018       };
87019     } catch (std::exception& e) {
87020       {
87021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87022       };
87023     } catch (...) {
87024       {
87025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87026       };
87027     }
87028   }
87029   jresult = (void *)result;
87030   return jresult;
87031 }
87032
87033
87034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87035   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87036   int arg2 ;
87037   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87038
87039   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87040   arg2 = (int)jarg2;
87041   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87042   if (!arg3) {
87043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87044     return ;
87045   }
87046   {
87047     try {
87048       try {
87049         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);
87050       }
87051       catch(std::out_of_range &_e) {
87052         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87053         return ;
87054       }
87055
87056     } catch (std::out_of_range& e) {
87057       {
87058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87059       };
87060     } catch (std::exception& e) {
87061       {
87062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87063       };
87064     } catch (...) {
87065       {
87066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87067       };
87068     }
87069   }
87070 }
87071
87072
87073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87075   int arg2 ;
87076   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87077
87078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87079   arg2 = (int)jarg2;
87080   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87081   if (!arg3) {
87082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87083     return ;
87084   }
87085   {
87086     try {
87087       try {
87088         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);
87089       }
87090       catch(std::out_of_range &_e) {
87091         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87092         return ;
87093       }
87094
87095     } catch (std::out_of_range& e) {
87096       {
87097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87098       };
87099     } catch (std::exception& e) {
87100       {
87101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87102       };
87103     } catch (...) {
87104       {
87105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87106       };
87107     }
87108   }
87109 }
87110
87111
87112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87113   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87114   int arg2 ;
87115
87116   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87117   arg2 = (int)jarg2;
87118   {
87119     try {
87120       try {
87121         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87122       }
87123       catch(std::out_of_range &_e) {
87124         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87125         return ;
87126       }
87127
87128     } catch (std::out_of_range& e) {
87129       {
87130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87131       };
87132     } catch (std::exception& e) {
87133       {
87134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87139       };
87140     }
87141   }
87142 }
87143
87144
87145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87146   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87147   int arg2 ;
87148   int arg3 ;
87149
87150   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87151   arg2 = (int)jarg2;
87152   arg3 = (int)jarg3;
87153   {
87154     try {
87155       try {
87156         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87157       }
87158       catch(std::out_of_range &_e) {
87159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87160         return ;
87161       }
87162       catch(std::invalid_argument &_e) {
87163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87164         return ;
87165       }
87166
87167     } catch (std::out_of_range& e) {
87168       {
87169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87170       };
87171     } catch (std::exception& e) {
87172       {
87173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87174       };
87175     } catch (...) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87178       };
87179     }
87180   }
87181 }
87182
87183
87184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87185   void * jresult ;
87186   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87187   int arg2 ;
87188   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87189
87190   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87191   if (!arg1) {
87192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87193     return 0;
87194   }
87195   arg2 = (int)jarg2;
87196   {
87197     try {
87198       try {
87199         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);
87200       }
87201       catch(std::out_of_range &_e) {
87202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87203         return 0;
87204       }
87205
87206     } catch (std::out_of_range& e) {
87207       {
87208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87209       };
87210     } catch (std::exception& e) {
87211       {
87212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87217       };
87218     }
87219   }
87220   jresult = (void *)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87226   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87227
87228   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87229   {
87230     try {
87231       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87232     } catch (std::out_of_range& e) {
87233       {
87234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87235       };
87236     } catch (std::exception& e) {
87237       {
87238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87239       };
87240     } catch (...) {
87241       {
87242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87243       };
87244     }
87245   }
87246 }
87247
87248
87249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87250   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87251   int arg2 ;
87252   int arg3 ;
87253
87254   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87255   arg2 = (int)jarg2;
87256   arg3 = (int)jarg3;
87257   {
87258     try {
87259       try {
87260         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87261       }
87262       catch(std::out_of_range &_e) {
87263         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87264         return ;
87265       }
87266       catch(std::invalid_argument &_e) {
87267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87268         return ;
87269       }
87270
87271     } catch (std::out_of_range& e) {
87272       {
87273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87274       };
87275     } catch (std::exception& e) {
87276       {
87277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87278       };
87279     } catch (...) {
87280       {
87281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87282       };
87283     }
87284   }
87285 }
87286
87287
87288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87289   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87290   int arg2 ;
87291   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87292
87293   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87294   arg2 = (int)jarg2;
87295   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87296   if (!arg3) {
87297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87298     return ;
87299   }
87300   {
87301     try {
87302       try {
87303         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);
87304       }
87305       catch(std::out_of_range &_e) {
87306         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87307         return ;
87308       }
87309
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87317       };
87318     } catch (...) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87321       };
87322     }
87323   }
87324 }
87325
87326
87327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87328   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87329
87330   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87331   {
87332     try {
87333       delete arg1;
87334     } catch (std::out_of_range& e) {
87335       {
87336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (std::exception& e) {
87339       {
87340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87341       };
87342     } catch (...) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87345       };
87346     }
87347   }
87348 }
87349
87350
87351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87352   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87353
87354   arg1 = (std::vector< Dali::Actor > *)jarg1;
87355   {
87356     try {
87357       (arg1)->clear();
87358     } catch (std::out_of_range& e) {
87359       {
87360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87361       };
87362     } catch (std::exception& e) {
87363       {
87364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87365       };
87366     } catch (...) {
87367       {
87368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87369       };
87370     }
87371   }
87372 }
87373
87374
87375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87376   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87377   Dali::Actor *arg2 = 0 ;
87378
87379   arg1 = (std::vector< Dali::Actor > *)jarg1;
87380   arg2 = (Dali::Actor *)jarg2;
87381   if (!arg2) {
87382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87383     return ;
87384   }
87385   {
87386     try {
87387       (arg1)->push_back((Dali::Actor const &)*arg2);
87388     } catch (std::out_of_range& e) {
87389       {
87390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87391       };
87392     } catch (std::exception& e) {
87393       {
87394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87395       };
87396     } catch (...) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87399       };
87400     }
87401   }
87402 }
87403
87404
87405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87406   unsigned long jresult ;
87407   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87408   std::vector< Dali::Actor >::size_type result;
87409
87410   arg1 = (std::vector< Dali::Actor > *)jarg1;
87411   {
87412     try {
87413       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87414     } catch (std::out_of_range& e) {
87415       {
87416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87417       };
87418     } catch (std::exception& e) {
87419       {
87420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87421       };
87422     } catch (...) {
87423       {
87424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87425       };
87426     }
87427   }
87428   jresult = (unsigned long)result;
87429   return jresult;
87430 }
87431
87432
87433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87434   unsigned long jresult ;
87435   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87436   std::vector< Dali::Actor >::size_type result;
87437
87438   arg1 = (std::vector< Dali::Actor > *)jarg1;
87439   {
87440     try {
87441       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87442     } catch (std::out_of_range& e) {
87443       {
87444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87445       };
87446     } catch (std::exception& e) {
87447       {
87448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (...) {
87451       {
87452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87453       };
87454     }
87455   }
87456   jresult = (unsigned long)result;
87457   return jresult;
87458 }
87459
87460
87461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87462   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87463   std::vector< Dali::Actor >::size_type arg2 ;
87464
87465   arg1 = (std::vector< Dali::Actor > *)jarg1;
87466   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87467   {
87468     try {
87469       (arg1)->reserve(arg2);
87470     } catch (std::out_of_range& e) {
87471       {
87472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87473       };
87474     } catch (std::exception& e) {
87475       {
87476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87477       };
87478     } catch (...) {
87479       {
87480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87481       };
87482     }
87483   }
87484 }
87485
87486
87487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87488   void * jresult ;
87489   std::vector< Dali::Actor > *result = 0 ;
87490
87491   {
87492     try {
87493       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87494     } catch (std::out_of_range& e) {
87495       {
87496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87497       };
87498     } catch (std::exception& e) {
87499       {
87500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87501       };
87502     } catch (...) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87505       };
87506     }
87507   }
87508   jresult = (void *)result;
87509   return jresult;
87510 }
87511
87512
87513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87514   void * jresult ;
87515   std::vector< Dali::Actor > *arg1 = 0 ;
87516   std::vector< Dali::Actor > *result = 0 ;
87517
87518   arg1 = (std::vector< Dali::Actor > *)jarg1;
87519   if (!arg1) {
87520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87521     return 0;
87522   }
87523   {
87524     try {
87525       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87526     } catch (std::out_of_range& e) {
87527       {
87528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87529       };
87530     } catch (std::exception& e) {
87531       {
87532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87533       };
87534     } catch (...) {
87535       {
87536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87537       };
87538     }
87539   }
87540   jresult = (void *)result;
87541   return jresult;
87542 }
87543
87544
87545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87546   void * jresult ;
87547   int arg1 ;
87548   std::vector< Dali::Actor > *result = 0 ;
87549
87550   arg1 = (int)jarg1;
87551   {
87552     try {
87553       try {
87554         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87555       }
87556       catch(std::out_of_range &_e) {
87557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87558         return 0;
87559       }
87560
87561     } catch (std::out_of_range& e) {
87562       {
87563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87564       };
87565     } catch (std::exception& e) {
87566       {
87567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87568       };
87569     } catch (...) {
87570       {
87571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87572       };
87573     }
87574   }
87575   jresult = (void *)result;
87576   return jresult;
87577 }
87578
87579
87580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87581   void * jresult ;
87582   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87583   int arg2 ;
87584   Dali::Actor result;
87585
87586   arg1 = (std::vector< Dali::Actor > *)jarg1;
87587   arg2 = (int)jarg2;
87588   {
87589     try {
87590       try {
87591         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87592       }
87593       catch(std::out_of_range &_e) {
87594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87595         return 0;
87596       }
87597
87598     } catch (std::out_of_range& e) {
87599       {
87600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87601       };
87602     } catch (std::exception& e) {
87603       {
87604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87605       };
87606     } catch (...) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87609       };
87610     }
87611   }
87612   jresult = new Dali::Actor((const Dali::Actor &)result);
87613   return jresult;
87614 }
87615
87616
87617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87618   void * jresult ;
87619   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87620   int arg2 ;
87621   Dali::Actor *result = 0 ;
87622
87623   arg1 = (std::vector< Dali::Actor > *)jarg1;
87624   arg2 = (int)jarg2;
87625   {
87626     try {
87627       try {
87628         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87629       }
87630       catch(std::out_of_range &_e) {
87631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87632         return 0;
87633       }
87634
87635     } catch (std::out_of_range& e) {
87636       {
87637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87638       };
87639     } catch (std::exception& e) {
87640       {
87641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87642       };
87643     } catch (...) {
87644       {
87645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87646       };
87647     }
87648   }
87649   jresult = (void *)result;
87650   return jresult;
87651 }
87652
87653
87654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87655   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87656   int arg2 ;
87657   Dali::Actor *arg3 = 0 ;
87658
87659   arg1 = (std::vector< Dali::Actor > *)jarg1;
87660   arg2 = (int)jarg2;
87661   arg3 = (Dali::Actor *)jarg3;
87662   if (!arg3) {
87663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87664     return ;
87665   }
87666   {
87667     try {
87668       try {
87669         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87670       }
87671       catch(std::out_of_range &_e) {
87672         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87673         return ;
87674       }
87675
87676     } catch (std::out_of_range& e) {
87677       {
87678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87679       };
87680     } catch (std::exception& e) {
87681       {
87682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87683       };
87684     } catch (...) {
87685       {
87686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87687       };
87688     }
87689   }
87690 }
87691
87692
87693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87694   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87695   std::vector< Dali::Actor > *arg2 = 0 ;
87696
87697   arg1 = (std::vector< Dali::Actor > *)jarg1;
87698   arg2 = (std::vector< Dali::Actor > *)jarg2;
87699   if (!arg2) {
87700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87701     return ;
87702   }
87703   {
87704     try {
87705       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87706     } catch (std::out_of_range& e) {
87707       {
87708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87709       };
87710     } catch (std::exception& e) {
87711       {
87712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87713       };
87714     } catch (...) {
87715       {
87716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87717       };
87718     }
87719   }
87720 }
87721
87722
87723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87724   void * jresult ;
87725   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87726   int arg2 ;
87727   int arg3 ;
87728   std::vector< Dali::Actor > *result = 0 ;
87729
87730   arg1 = (std::vector< Dali::Actor > *)jarg1;
87731   arg2 = (int)jarg2;
87732   arg3 = (int)jarg3;
87733   {
87734     try {
87735       try {
87736         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87737       }
87738       catch(std::out_of_range &_e) {
87739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87740         return 0;
87741       }
87742       catch(std::invalid_argument &_e) {
87743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87744         return 0;
87745       }
87746
87747     } catch (std::out_of_range& e) {
87748       {
87749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87750       };
87751     } catch (std::exception& e) {
87752       {
87753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87754       };
87755     } catch (...) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87758       };
87759     }
87760   }
87761   jresult = (void *)result;
87762   return jresult;
87763 }
87764
87765
87766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87767   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87768   int arg2 ;
87769   Dali::Actor *arg3 = 0 ;
87770
87771   arg1 = (std::vector< Dali::Actor > *)jarg1;
87772   arg2 = (int)jarg2;
87773   arg3 = (Dali::Actor *)jarg3;
87774   if (!arg3) {
87775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87776     return ;
87777   }
87778   {
87779     try {
87780       try {
87781         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87782       }
87783       catch(std::out_of_range &_e) {
87784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87785         return ;
87786       }
87787
87788     } catch (std::out_of_range& e) {
87789       {
87790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87791       };
87792     } catch (std::exception& e) {
87793       {
87794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87795       };
87796     } catch (...) {
87797       {
87798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87799       };
87800     }
87801   }
87802 }
87803
87804
87805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87806   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87807   int arg2 ;
87808   std::vector< Dali::Actor > *arg3 = 0 ;
87809
87810   arg1 = (std::vector< Dali::Actor > *)jarg1;
87811   arg2 = (int)jarg2;
87812   arg3 = (std::vector< Dali::Actor > *)jarg3;
87813   if (!arg3) {
87814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87815     return ;
87816   }
87817   {
87818     try {
87819       try {
87820         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87821       }
87822       catch(std::out_of_range &_e) {
87823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87824         return ;
87825       }
87826
87827     } catch (std::out_of_range& e) {
87828       {
87829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87830       };
87831     } catch (std::exception& e) {
87832       {
87833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87834       };
87835     } catch (...) {
87836       {
87837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87838       };
87839     }
87840   }
87841 }
87842
87843
87844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87845   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87846   int arg2 ;
87847
87848   arg1 = (std::vector< Dali::Actor > *)jarg1;
87849   arg2 = (int)jarg2;
87850   {
87851     try {
87852       try {
87853         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87854       }
87855       catch(std::out_of_range &_e) {
87856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87857         return ;
87858       }
87859
87860     } catch (std::out_of_range& e) {
87861       {
87862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87863       };
87864     } catch (std::exception& e) {
87865       {
87866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87867       };
87868     } catch (...) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87871       };
87872     }
87873   }
87874 }
87875
87876
87877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87878   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87879   int arg2 ;
87880   int arg3 ;
87881
87882   arg1 = (std::vector< Dali::Actor > *)jarg1;
87883   arg2 = (int)jarg2;
87884   arg3 = (int)jarg3;
87885   {
87886     try {
87887       try {
87888         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87889       }
87890       catch(std::out_of_range &_e) {
87891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87892         return ;
87893       }
87894       catch(std::invalid_argument &_e) {
87895         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87896         return ;
87897       }
87898
87899     } catch (std::out_of_range& e) {
87900       {
87901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87902       };
87903     } catch (std::exception& e) {
87904       {
87905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87906       };
87907     } catch (...) {
87908       {
87909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87910       };
87911     }
87912   }
87913 }
87914
87915
87916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87917   void * jresult ;
87918   Dali::Actor *arg1 = 0 ;
87919   int arg2 ;
87920   std::vector< Dali::Actor > *result = 0 ;
87921
87922   arg1 = (Dali::Actor *)jarg1;
87923   if (!arg1) {
87924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87925     return 0;
87926   }
87927   arg2 = (int)jarg2;
87928   {
87929     try {
87930       try {
87931         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87932       }
87933       catch(std::out_of_range &_e) {
87934         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87935         return 0;
87936       }
87937
87938     } catch (std::out_of_range& e) {
87939       {
87940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87941       };
87942     } catch (std::exception& e) {
87943       {
87944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87945       };
87946     } catch (...) {
87947       {
87948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87949       };
87950     }
87951   }
87952   jresult = (void *)result;
87953   return jresult;
87954 }
87955
87956
87957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87958   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87959
87960   arg1 = (std::vector< Dali::Actor > *)jarg1;
87961   {
87962     try {
87963       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87964     } catch (std::out_of_range& e) {
87965       {
87966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87967       };
87968     } catch (std::exception& e) {
87969       {
87970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87975       };
87976     }
87977   }
87978 }
87979
87980
87981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87982   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87983   int arg2 ;
87984   int arg3 ;
87985
87986   arg1 = (std::vector< Dali::Actor > *)jarg1;
87987   arg2 = (int)jarg2;
87988   arg3 = (int)jarg3;
87989   {
87990     try {
87991       try {
87992         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87993       }
87994       catch(std::out_of_range &_e) {
87995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87996         return ;
87997       }
87998       catch(std::invalid_argument &_e) {
87999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88000         return ;
88001       }
88002
88003     } catch (std::out_of_range& e) {
88004       {
88005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88006       };
88007     } catch (std::exception& e) {
88008       {
88009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88010       };
88011     } catch (...) {
88012       {
88013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88014       };
88015     }
88016   }
88017 }
88018
88019
88020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88021   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88022   int arg2 ;
88023   std::vector< Dali::Actor > *arg3 = 0 ;
88024
88025   arg1 = (std::vector< Dali::Actor > *)jarg1;
88026   arg2 = (int)jarg2;
88027   arg3 = (std::vector< Dali::Actor > *)jarg3;
88028   if (!arg3) {
88029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88030     return ;
88031   }
88032   {
88033     try {
88034       try {
88035         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88036       }
88037       catch(std::out_of_range &_e) {
88038         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88039         return ;
88040       }
88041
88042     } catch (std::out_of_range& e) {
88043       {
88044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88045       };
88046     } catch (std::exception& e) {
88047       {
88048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88049       };
88050     } catch (...) {
88051       {
88052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88053       };
88054     }
88055   }
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88060   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88061
88062   arg1 = (std::vector< Dali::Actor > *)jarg1;
88063   {
88064     try {
88065       delete arg1;
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88073       };
88074     } catch (...) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88077       };
88078     }
88079   }
88080 }
88081
88082
88083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88084   unsigned int jresult ;
88085   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88086   bool result;
88087
88088   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88089   {
88090     try {
88091       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88092     } catch (std::out_of_range& e) {
88093       {
88094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88095       };
88096     } catch (std::exception& e) {
88097       {
88098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88099       };
88100     } catch (...) {
88101       {
88102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88103       };
88104     }
88105   }
88106   jresult = result;
88107   return jresult;
88108 }
88109
88110
88111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88112   unsigned long jresult ;
88113   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88114   std::size_t result;
88115
88116   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88117   {
88118     try {
88119       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88120     } catch (std::out_of_range& e) {
88121       {
88122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88123       };
88124     } catch (std::exception& e) {
88125       {
88126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88127       };
88128     } catch (...) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88131       };
88132     }
88133   }
88134   jresult = (unsigned long)result;
88135   return jresult;
88136 }
88137
88138
88139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88140   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88141   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88142
88143   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88144   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88145   {
88146     try {
88147       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88148     } catch (std::out_of_range& e) {
88149       {
88150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88151       };
88152     } catch (std::exception& e) {
88153       {
88154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88155       };
88156     } catch (...) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88159       };
88160     }
88161   }
88162 }
88163
88164
88165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88166   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88167   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88168
88169   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88170   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88171   {
88172     try {
88173       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88174     } catch (std::out_of_range& e) {
88175       {
88176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88177       };
88178     } catch (std::exception& e) {
88179       {
88180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88181       };
88182     } catch (...) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88185       };
88186     }
88187   }
88188 }
88189
88190
88191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88192   unsigned int jresult ;
88193   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88194   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88195   bool result;
88196
88197   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88198   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88199   if (!arg2) {
88200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88201     return 0;
88202   }
88203   {
88204     try {
88205       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88206     } catch (std::out_of_range& e) {
88207       {
88208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (std::exception& e) {
88211       {
88212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88213       };
88214     } catch (...) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88217       };
88218     }
88219   }
88220   jresult = result;
88221   return jresult;
88222 }
88223
88224
88225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88226   void * jresult ;
88227   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88228
88229   {
88230     try {
88231       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (...) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88243       };
88244     }
88245   }
88246   jresult = (void *)result;
88247   return jresult;
88248 }
88249
88250
88251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88252   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88253
88254   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88255   {
88256     try {
88257       delete arg1;
88258     } catch (std::out_of_range& e) {
88259       {
88260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88261       };
88262     } catch (std::exception& e) {
88263       {
88264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88265       };
88266     } catch (...) {
88267       {
88268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88269       };
88270     }
88271   }
88272 }
88273
88274
88275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88276   unsigned int jresult ;
88277   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88278   bool result;
88279
88280   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88281   {
88282     try {
88283       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);
88284     } catch (std::out_of_range& e) {
88285       {
88286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88287       };
88288     } catch (std::exception& e) {
88289       {
88290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88291       };
88292     } catch (...) {
88293       {
88294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88295       };
88296     }
88297   }
88298   jresult = result;
88299   return jresult;
88300 }
88301
88302
88303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88304   unsigned long jresult ;
88305   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88306   std::size_t result;
88307
88308   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88309   {
88310     try {
88311       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);
88312     } catch (std::out_of_range& e) {
88313       {
88314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (std::exception& e) {
88317       {
88318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88319       };
88320     } catch (...) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88323       };
88324     }
88325   }
88326   jresult = (unsigned long)result;
88327   return jresult;
88328 }
88329
88330
88331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88332   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88333   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88334
88335   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88336   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88337   {
88338     try {
88339       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88340     } catch (std::out_of_range& e) {
88341       {
88342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88343       };
88344     } catch (std::exception& e) {
88345       {
88346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88347       };
88348     } catch (...) {
88349       {
88350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88351       };
88352     }
88353   }
88354 }
88355
88356
88357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88358   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88359   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88360
88361   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88362   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88363   {
88364     try {
88365       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88366     } catch (std::out_of_range& e) {
88367       {
88368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88369       };
88370     } catch (std::exception& e) {
88371       {
88372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88373       };
88374     } catch (...) {
88375       {
88376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88377       };
88378     }
88379   }
88380 }
88381
88382
88383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88384   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88385   Dali::Actor arg2 ;
88386   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88387   Dali::Actor *argp2 ;
88388
88389   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88390   argp2 = (Dali::Actor *)jarg2;
88391   if (!argp2) {
88392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88393     return ;
88394   }
88395   arg2 = *argp2;
88396   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88397   {
88398     try {
88399       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88400     } catch (std::out_of_range& e) {
88401       {
88402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88403       };
88404     } catch (std::exception& e) {
88405       {
88406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88407       };
88408     } catch (...) {
88409       {
88410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88411       };
88412     }
88413   }
88414 }
88415
88416
88417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88418   void * jresult ;
88419   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88420
88421   {
88422     try {
88423       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88424     } catch (std::out_of_range& e) {
88425       {
88426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88427       };
88428     } catch (std::exception& e) {
88429       {
88430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88431       };
88432     } catch (...) {
88433       {
88434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88435       };
88436     }
88437   }
88438   jresult = (void *)result;
88439   return jresult;
88440 }
88441
88442
88443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88444   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88445
88446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88447   {
88448     try {
88449       delete arg1;
88450     } catch (std::out_of_range& e) {
88451       {
88452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88453       };
88454     } catch (std::exception& e) {
88455       {
88456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88457       };
88458     } catch (...) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88461       };
88462     }
88463   }
88464 }
88465
88466
88467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88468   unsigned int jresult ;
88469   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88470   bool result;
88471
88472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88473   {
88474     try {
88475       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88476     } catch (std::out_of_range& e) {
88477       {
88478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88479       };
88480     } catch (std::exception& e) {
88481       {
88482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88483       };
88484     } catch (...) {
88485       {
88486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88487       };
88488     }
88489   }
88490   jresult = result;
88491   return jresult;
88492 }
88493
88494
88495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88496   unsigned long jresult ;
88497   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88498   std::size_t result;
88499
88500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88501   {
88502     try {
88503       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88504     } catch (std::out_of_range& e) {
88505       {
88506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88507       };
88508     } catch (std::exception& e) {
88509       {
88510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88511       };
88512     } catch (...) {
88513       {
88514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88515       };
88516     }
88517   }
88518   jresult = (unsigned long)result;
88519   return jresult;
88520 }
88521
88522
88523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88524   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88525   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88526
88527   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88528   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88529   {
88530     try {
88531       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88532     } catch (std::out_of_range& e) {
88533       {
88534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88535       };
88536     } catch (std::exception& e) {
88537       {
88538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88539       };
88540     } catch (...) {
88541       {
88542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88543       };
88544     }
88545   }
88546 }
88547
88548
88549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88550   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88551   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88552
88553   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88554   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88555   {
88556     try {
88557       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88558     } catch (std::out_of_range& e) {
88559       {
88560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88561       };
88562     } catch (std::exception& e) {
88563       {
88564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88565       };
88566     } catch (...) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88569       };
88570     }
88571   }
88572 }
88573
88574
88575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88576   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88577   Dali::Actor arg2 ;
88578   Dali::Actor arg3 ;
88579   Dali::Actor *argp2 ;
88580   Dali::Actor *argp3 ;
88581
88582   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88583   argp2 = (Dali::Actor *)jarg2;
88584   if (!argp2) {
88585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88586     return ;
88587   }
88588   arg2 = *argp2;
88589   argp3 = (Dali::Actor *)jarg3;
88590   if (!argp3) {
88591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88592     return ;
88593   }
88594   arg3 = *argp3;
88595   {
88596     try {
88597       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88598     } catch (std::out_of_range& e) {
88599       {
88600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88601       };
88602     } catch (std::exception& e) {
88603       {
88604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88605       };
88606     } catch (...) {
88607       {
88608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88609       };
88610     }
88611   }
88612 }
88613
88614
88615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88616   void * jresult ;
88617   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88618
88619   {
88620     try {
88621       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88622     } catch (std::out_of_range& e) {
88623       {
88624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (std::exception& e) {
88627       {
88628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (...) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88633       };
88634     }
88635   }
88636   jresult = (void *)result;
88637   return jresult;
88638 }
88639
88640
88641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88642   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88643
88644   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88645   {
88646     try {
88647       delete arg1;
88648     } catch (std::out_of_range& e) {
88649       {
88650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (std::exception& e) {
88653       {
88654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662 }
88663
88664
88665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88666   unsigned int jresult ;
88667   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88668   bool result;
88669
88670   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88671   {
88672     try {
88673       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88674     } catch (std::out_of_range& e) {
88675       {
88676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88677       };
88678     } catch (std::exception& e) {
88679       {
88680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88681       };
88682     } catch (...) {
88683       {
88684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88685       };
88686     }
88687   }
88688   jresult = result;
88689   return jresult;
88690 }
88691
88692
88693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88694   unsigned long jresult ;
88695   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88696   std::size_t result;
88697
88698   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88699   {
88700     try {
88701       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88702     } catch (std::out_of_range& e) {
88703       {
88704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88705       };
88706     } catch (std::exception& e) {
88707       {
88708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88713       };
88714     }
88715   }
88716   jresult = (unsigned long)result;
88717   return jresult;
88718 }
88719
88720
88721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88722   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88723   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88724
88725   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88726   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88727   {
88728     try {
88729       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88730     } catch (std::out_of_range& e) {
88731       {
88732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88733       };
88734     } catch (std::exception& e) {
88735       {
88736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88737       };
88738     } catch (...) {
88739       {
88740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88741       };
88742     }
88743   }
88744 }
88745
88746
88747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88748   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88749   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88750
88751   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88752   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88753   {
88754     try {
88755       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88756     } catch (std::out_of_range& e) {
88757       {
88758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88759       };
88760     } catch (std::exception& e) {
88761       {
88762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88763       };
88764     } catch (...) {
88765       {
88766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88767       };
88768     }
88769   }
88770 }
88771
88772
88773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88774   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88775   Dali::Actor arg2 ;
88776   bool arg3 ;
88777   Dali::Actor *argp2 ;
88778
88779   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88780   argp2 = (Dali::Actor *)jarg2;
88781   if (!argp2) {
88782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88783     return ;
88784   }
88785   arg2 = *argp2;
88786   arg3 = jarg3 ? true : false;
88787   {
88788     try {
88789       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88790     } catch (std::out_of_range& e) {
88791       {
88792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88793       };
88794     } catch (std::exception& e) {
88795       {
88796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88797       };
88798     } catch (...) {
88799       {
88800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88801       };
88802     }
88803   }
88804 }
88805
88806
88807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88808   void * jresult ;
88809   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88810
88811   {
88812     try {
88813       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88814     } catch (std::out_of_range& e) {
88815       {
88816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88817       };
88818     } catch (std::exception& e) {
88819       {
88820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88821       };
88822     } catch (...) {
88823       {
88824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88825       };
88826     }
88827   }
88828   jresult = (void *)result;
88829   return jresult;
88830 }
88831
88832
88833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88834   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88835
88836   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88837   {
88838     try {
88839       delete arg1;
88840     } catch (std::out_of_range& e) {
88841       {
88842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88843       };
88844     } catch (std::exception& e) {
88845       {
88846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88847       };
88848     } catch (...) {
88849       {
88850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88851       };
88852     }
88853   }
88854 }
88855
88856
88857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88858   unsigned int jresult ;
88859   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88860   bool result;
88861
88862   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88863   {
88864     try {
88865       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);
88866     } catch (std::out_of_range& e) {
88867       {
88868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (std::exception& e) {
88871       {
88872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88877       };
88878     }
88879   }
88880   jresult = result;
88881   return jresult;
88882 }
88883
88884
88885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88886   unsigned long jresult ;
88887   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88888   std::size_t result;
88889
88890   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88891   {
88892     try {
88893       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);
88894     } catch (std::out_of_range& e) {
88895       {
88896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88897       };
88898     } catch (std::exception& e) {
88899       {
88900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88901       };
88902     } catch (...) {
88903       {
88904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88905       };
88906     }
88907   }
88908   jresult = (unsigned long)result;
88909   return jresult;
88910 }
88911
88912
88913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88914   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88915   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88916
88917   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88918   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88919   {
88920     try {
88921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88922     } catch (std::out_of_range& e) {
88923       {
88924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88925       };
88926     } catch (std::exception& e) {
88927       {
88928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88933       };
88934     }
88935   }
88936 }
88937
88938
88939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88940   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88941   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88942
88943   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88944   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88945   {
88946     try {
88947       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88948     } catch (std::out_of_range& e) {
88949       {
88950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88951       };
88952     } catch (std::exception& e) {
88953       {
88954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88955       };
88956     } catch (...) {
88957       {
88958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88959       };
88960     }
88961   }
88962 }
88963
88964
88965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88966   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88967   Dali::Toolkit::StyleManager arg2 ;
88968   Dali::StyleChange::Type arg3 ;
88969   Dali::Toolkit::StyleManager *argp2 ;
88970
88971   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88972   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88973   if (!argp2) {
88974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88975     return ;
88976   }
88977   arg2 = *argp2;
88978   arg3 = (Dali::StyleChange::Type)jarg3;
88979   {
88980     try {
88981       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88982     } catch (std::out_of_range& e) {
88983       {
88984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88985       };
88986     } catch (std::exception& e) {
88987       {
88988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88989       };
88990     } catch (...) {
88991       {
88992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88993       };
88994     }
88995   }
88996 }
88997
88998
88999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89000   void * jresult ;
89001   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89002
89003   {
89004     try {
89005       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89006     } catch (std::out_of_range& e) {
89007       {
89008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (std::exception& e) {
89011       {
89012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89017       };
89018     }
89019   }
89020   jresult = (void *)result;
89021   return jresult;
89022 }
89023
89024
89025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89026   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89027
89028   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89029   {
89030     try {
89031       delete arg1;
89032     } catch (std::out_of_range& e) {
89033       {
89034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89035       };
89036     } catch (std::exception& e) {
89037       {
89038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89039       };
89040     } catch (...) {
89041       {
89042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89043       };
89044     }
89045   }
89046 }
89047
89048
89049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89050   unsigned int jresult ;
89051   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89052   bool result;
89053
89054   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89055   {
89056     try {
89057       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89058     } catch (std::out_of_range& e) {
89059       {
89060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89061       };
89062     } catch (std::exception& e) {
89063       {
89064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89065       };
89066     } catch (...) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89069       };
89070     }
89071   }
89072   jresult = result;
89073   return jresult;
89074 }
89075
89076
89077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89078   unsigned long jresult ;
89079   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89080   std::size_t result;
89081
89082   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89083   {
89084     try {
89085       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89086     } catch (std::out_of_range& e) {
89087       {
89088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89089       };
89090     } catch (std::exception& e) {
89091       {
89092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89093       };
89094     } catch (...) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89097       };
89098     }
89099   }
89100   jresult = (unsigned long)result;
89101   return jresult;
89102 }
89103
89104
89105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89106   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89107   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89108
89109   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89110   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89111   {
89112     try {
89113       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89114     } catch (std::out_of_range& e) {
89115       {
89116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89117       };
89118     } catch (std::exception& e) {
89119       {
89120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89121       };
89122     } catch (...) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89125       };
89126     }
89127   }
89128 }
89129
89130
89131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89132   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89133   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89134
89135   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89136   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89137   {
89138     try {
89139       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89140     } catch (std::out_of_range& e) {
89141       {
89142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89143       };
89144     } catch (std::exception& e) {
89145       {
89146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89147       };
89148     } catch (...) {
89149       {
89150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89151       };
89152     }
89153   }
89154 }
89155
89156
89157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89158   unsigned int jresult ;
89159   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89160   Dali::Toolkit::Button arg2 ;
89161   Dali::Toolkit::Button *argp2 ;
89162   bool result;
89163
89164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89165   argp2 = (Dali::Toolkit::Button *)jarg2;
89166   if (!argp2) {
89167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89168     return 0;
89169   }
89170   arg2 = *argp2;
89171   {
89172     try {
89173       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89181       };
89182     } catch (...) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89185       };
89186     }
89187   }
89188   jresult = result;
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89194   void * jresult ;
89195   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89196
89197   {
89198     try {
89199       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89200     } catch (std::out_of_range& e) {
89201       {
89202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89203       };
89204     } catch (std::exception& e) {
89205       {
89206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89207       };
89208     } catch (...) {
89209       {
89210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89211       };
89212     }
89213   }
89214   jresult = (void *)result;
89215   return jresult;
89216 }
89217
89218
89219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89220   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89221
89222   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89223   {
89224     try {
89225       delete arg1;
89226     } catch (std::out_of_range& e) {
89227       {
89228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89229       };
89230     } catch (std::exception& e) {
89231       {
89232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89233       };
89234     } catch (...) {
89235       {
89236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89237       };
89238     }
89239   }
89240 }
89241
89242
89243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89244   unsigned int jresult ;
89245   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89246   bool result;
89247
89248   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89249   {
89250     try {
89251       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89252     } catch (std::out_of_range& e) {
89253       {
89254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89255       };
89256     } catch (std::exception& e) {
89257       {
89258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89259       };
89260     } catch (...) {
89261       {
89262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89263       };
89264     }
89265   }
89266   jresult = result;
89267   return jresult;
89268 }
89269
89270
89271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89272   unsigned long jresult ;
89273   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89274   std::size_t result;
89275
89276   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89277   {
89278     try {
89279       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89280     } catch (std::out_of_range& e) {
89281       {
89282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89283       };
89284     } catch (std::exception& e) {
89285       {
89286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89287       };
89288     } catch (...) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89291       };
89292     }
89293   }
89294   jresult = (unsigned long)result;
89295   return jresult;
89296 }
89297
89298
89299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89300   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89301   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89302
89303   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89304   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89305   {
89306     try {
89307       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89308     } catch (std::out_of_range& e) {
89309       {
89310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89311       };
89312     } catch (std::exception& e) {
89313       {
89314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89315       };
89316     } catch (...) {
89317       {
89318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89319       };
89320     }
89321   }
89322 }
89323
89324
89325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89326   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89327   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89328
89329   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89330   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89331   {
89332     try {
89333       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89334     } catch (std::out_of_range& e) {
89335       {
89336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89337       };
89338     } catch (std::exception& e) {
89339       {
89340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89341       };
89342     } catch (...) {
89343       {
89344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89345       };
89346     }
89347   }
89348 }
89349
89350
89351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89352   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89353   Dali::Toolkit::GaussianBlurView arg2 ;
89354   Dali::Toolkit::GaussianBlurView *argp2 ;
89355
89356   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89357   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89358   if (!argp2) {
89359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89360     return ;
89361   }
89362   arg2 = *argp2;
89363   {
89364     try {
89365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89366     } catch (std::out_of_range& e) {
89367       {
89368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89369       };
89370     } catch (std::exception& e) {
89371       {
89372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (...) {
89375       {
89376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89377       };
89378     }
89379   }
89380 }
89381
89382
89383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89384   void * jresult ;
89385   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89386
89387   {
89388     try {
89389       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89390     } catch (std::out_of_range& e) {
89391       {
89392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89393       };
89394     } catch (std::exception& e) {
89395       {
89396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89397       };
89398     } catch (...) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89401       };
89402     }
89403   }
89404   jresult = (void *)result;
89405   return jresult;
89406 }
89407
89408
89409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89410   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89411
89412   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89413   {
89414     try {
89415       delete arg1;
89416     } catch (std::out_of_range& e) {
89417       {
89418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89419       };
89420     } catch (std::exception& e) {
89421       {
89422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89423       };
89424     } catch (...) {
89425       {
89426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89427       };
89428     }
89429   }
89430 }
89431
89432
89433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89434   unsigned int jresult ;
89435   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89436   bool result;
89437
89438   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89439   {
89440     try {
89441       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);
89442     } catch (std::out_of_range& e) {
89443       {
89444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89445       };
89446     } catch (std::exception& e) {
89447       {
89448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89449       };
89450     } catch (...) {
89451       {
89452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89453       };
89454     }
89455   }
89456   jresult = result;
89457   return jresult;
89458 }
89459
89460
89461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89462   unsigned long jresult ;
89463   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89464   std::size_t result;
89465
89466   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89467   {
89468     try {
89469       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);
89470     } catch (std::out_of_range& e) {
89471       {
89472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89473       };
89474     } catch (std::exception& e) {
89475       {
89476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89477       };
89478     } catch (...) {
89479       {
89480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89481       };
89482     }
89483   }
89484   jresult = (unsigned long)result;
89485   return jresult;
89486 }
89487
89488
89489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89490   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89491   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89492
89493   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89494   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89495   {
89496     try {
89497       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89498     } catch (std::out_of_range& e) {
89499       {
89500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89501       };
89502     } catch (std::exception& e) {
89503       {
89504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89505       };
89506     } catch (...) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89509       };
89510     }
89511   }
89512 }
89513
89514
89515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89516   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89517   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89518
89519   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89520   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89521   {
89522     try {
89523       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89524     } catch (std::out_of_range& e) {
89525       {
89526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89527       };
89528     } catch (std::exception& e) {
89529       {
89530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89531       };
89532     } catch (...) {
89533       {
89534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89535       };
89536     }
89537   }
89538 }
89539
89540
89541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89542   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89543   Dali::Toolkit::PageTurnView arg2 ;
89544   unsigned int arg3 ;
89545   bool arg4 ;
89546   Dali::Toolkit::PageTurnView *argp2 ;
89547
89548   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89549   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89550   if (!argp2) {
89551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89552     return ;
89553   }
89554   arg2 = *argp2;
89555   arg3 = (unsigned int)jarg3;
89556   arg4 = jarg4 ? true : false;
89557   {
89558     try {
89559       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89560     } catch (std::out_of_range& e) {
89561       {
89562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89563       };
89564     } catch (std::exception& e) {
89565       {
89566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89567       };
89568     } catch (...) {
89569       {
89570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89571       };
89572     }
89573   }
89574 }
89575
89576
89577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89578   void * jresult ;
89579   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89580
89581   {
89582     try {
89583       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89584     } catch (std::out_of_range& e) {
89585       {
89586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89587       };
89588     } catch (std::exception& e) {
89589       {
89590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89591       };
89592     } catch (...) {
89593       {
89594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89595       };
89596     }
89597   }
89598   jresult = (void *)result;
89599   return jresult;
89600 }
89601
89602
89603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89604   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89605
89606   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89607   {
89608     try {
89609       delete arg1;
89610     } catch (std::out_of_range& e) {
89611       {
89612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89613       };
89614     } catch (std::exception& e) {
89615       {
89616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89617       };
89618     } catch (...) {
89619       {
89620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89621       };
89622     }
89623   }
89624 }
89625
89626
89627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89628   unsigned int jresult ;
89629   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89630   bool result;
89631
89632   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89633   {
89634     try {
89635       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89636     } catch (std::out_of_range& e) {
89637       {
89638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89639       };
89640     } catch (std::exception& e) {
89641       {
89642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89643       };
89644     } catch (...) {
89645       {
89646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89647       };
89648     }
89649   }
89650   jresult = result;
89651   return jresult;
89652 }
89653
89654
89655 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89656   unsigned long jresult ;
89657   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89658   std::size_t result;
89659
89660   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89661   {
89662     try {
89663       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89671       };
89672     } catch (...) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89675       };
89676     }
89677   }
89678   jresult = (unsigned long)result;
89679   return jresult;
89680 }
89681
89682
89683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89684   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89685   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89686
89687   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89688   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89689   {
89690     try {
89691       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89692     } catch (std::out_of_range& e) {
89693       {
89694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89695       };
89696     } catch (std::exception& e) {
89697       {
89698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89699       };
89700     } catch (...) {
89701       {
89702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89703       };
89704     }
89705   }
89706 }
89707
89708
89709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89710   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89711   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89712
89713   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89714   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89715   {
89716     try {
89717       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89718     } catch (std::out_of_range& e) {
89719       {
89720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89721       };
89722     } catch (std::exception& e) {
89723       {
89724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89725       };
89726     } catch (...) {
89727       {
89728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89729       };
89730     }
89731   }
89732 }
89733
89734
89735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89736   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89737   Dali::Toolkit::PageTurnView arg2 ;
89738   Dali::Toolkit::PageTurnView *argp2 ;
89739
89740   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89741   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89742   if (!argp2) {
89743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89744     return ;
89745   }
89746   arg2 = *argp2;
89747   {
89748     try {
89749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89750     } catch (std::out_of_range& e) {
89751       {
89752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89753       };
89754     } catch (std::exception& e) {
89755       {
89756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89757       };
89758     } catch (...) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89761       };
89762     }
89763   }
89764 }
89765
89766
89767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89768   void * jresult ;
89769   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89770
89771   {
89772     try {
89773       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89774     } catch (std::out_of_range& e) {
89775       {
89776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89777       };
89778     } catch (std::exception& e) {
89779       {
89780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89781       };
89782     } catch (...) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89785       };
89786     }
89787   }
89788   jresult = (void *)result;
89789   return jresult;
89790 }
89791
89792
89793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89794   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89795
89796   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89797   {
89798     try {
89799       delete arg1;
89800     } catch (std::out_of_range& e) {
89801       {
89802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89803       };
89804     } catch (std::exception& e) {
89805       {
89806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89807       };
89808     } catch (...) {
89809       {
89810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89811       };
89812     }
89813   }
89814 }
89815
89816
89817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89818   unsigned int jresult ;
89819   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89820   bool result;
89821
89822   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89823   {
89824     try {
89825       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);
89826     } catch (std::out_of_range& e) {
89827       {
89828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89829       };
89830     } catch (std::exception& e) {
89831       {
89832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89833       };
89834     } catch (...) {
89835       {
89836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89837       };
89838     }
89839   }
89840   jresult = result;
89841   return jresult;
89842 }
89843
89844
89845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89846   unsigned long jresult ;
89847   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89848   std::size_t result;
89849
89850   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89851   {
89852     try {
89853       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);
89854     } catch (std::out_of_range& e) {
89855       {
89856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89857       };
89858     } catch (std::exception& e) {
89859       {
89860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89861       };
89862     } catch (...) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89865       };
89866     }
89867   }
89868   jresult = (unsigned long)result;
89869   return jresult;
89870 }
89871
89872
89873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89874   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89875   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89876
89877   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89878   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89879   {
89880     try {
89881       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89882     } catch (std::out_of_range& e) {
89883       {
89884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89885       };
89886     } catch (std::exception& e) {
89887       {
89888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89889       };
89890     } catch (...) {
89891       {
89892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89893       };
89894     }
89895   }
89896 }
89897
89898
89899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89900   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89901   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89902
89903   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89904   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89905   {
89906     try {
89907       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
89908     } catch (std::out_of_range& e) {
89909       {
89910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89911       };
89912     } catch (std::exception& e) {
89913       {
89914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89915       };
89916     } catch (...) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89919       };
89920     }
89921   }
89922 }
89923
89924
89925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
89926   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89927   Dali::Toolkit::ProgressBar arg2 ;
89928   float arg3 ;
89929   float arg4 ;
89930   Dali::Toolkit::ProgressBar *argp2 ;
89931
89932   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89933   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
89934   if (!argp2) {
89935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
89936     return ;
89937   }
89938   arg2 = *argp2;
89939   arg3 = (float)jarg3;
89940   arg4 = (float)jarg4;
89941   {
89942     try {
89943       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89944     } catch (std::out_of_range& e) {
89945       {
89946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89947       };
89948     } catch (std::exception& e) {
89949       {
89950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89951       };
89952     } catch (...) {
89953       {
89954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89955       };
89956     }
89957   }
89958 }
89959
89960
89961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
89962   void * jresult ;
89963   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
89964
89965   {
89966     try {
89967       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
89968     } catch (std::out_of_range& e) {
89969       {
89970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89971       };
89972     } catch (std::exception& e) {
89973       {
89974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89975       };
89976     } catch (...) {
89977       {
89978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89979       };
89980     }
89981   }
89982   jresult = (void *)result;
89983   return jresult;
89984 }
89985
89986
89987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
89988   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89989
89990   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89991   {
89992     try {
89993       delete arg1;
89994     } catch (std::out_of_range& e) {
89995       {
89996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89997       };
89998     } catch (std::exception& e) {
89999       {
90000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90005       };
90006     }
90007   }
90008 }
90009
90010
90011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90012   unsigned int jresult ;
90013   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90014   bool result;
90015
90016   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90017   {
90018     try {
90019       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);
90020     } catch (std::out_of_range& e) {
90021       {
90022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90023       };
90024     } catch (std::exception& e) {
90025       {
90026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90027       };
90028     } catch (...) {
90029       {
90030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90031       };
90032     }
90033   }
90034   jresult = result;
90035   return jresult;
90036 }
90037
90038
90039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90040   unsigned long jresult ;
90041   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90042   std::size_t result;
90043
90044   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90045   {
90046     try {
90047       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);
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90059       };
90060     }
90061   }
90062   jresult = (unsigned long)result;
90063   return jresult;
90064 }
90065
90066
90067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90068   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90069   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90070
90071   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90072   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90073   {
90074     try {
90075       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90076     } catch (std::out_of_range& e) {
90077       {
90078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90079       };
90080     } catch (std::exception& e) {
90081       {
90082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90083       };
90084     } catch (...) {
90085       {
90086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90087       };
90088     }
90089   }
90090 }
90091
90092
90093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90094   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90095   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90096
90097   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90098   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90099   {
90100     try {
90101       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90102     } catch (std::out_of_range& e) {
90103       {
90104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90105       };
90106     } catch (std::exception& e) {
90107       {
90108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90109       };
90110     } catch (...) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90113       };
90114     }
90115   }
90116 }
90117
90118
90119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90120   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90121   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90122
90123   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90124   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90125   if (!arg2) {
90126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90127     return ;
90128   }
90129   {
90130     try {
90131       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90132     } catch (std::out_of_range& e) {
90133       {
90134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90135       };
90136     } catch (std::exception& e) {
90137       {
90138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90139       };
90140     } catch (...) {
90141       {
90142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90143       };
90144     }
90145   }
90146 }
90147
90148
90149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90150   void * jresult ;
90151   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90152
90153   {
90154     try {
90155       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90156     } catch (std::out_of_range& e) {
90157       {
90158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90159       };
90160     } catch (std::exception& e) {
90161       {
90162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90163       };
90164     } catch (...) {
90165       {
90166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90167       };
90168     }
90169   }
90170   jresult = (void *)result;
90171   return jresult;
90172 }
90173
90174
90175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90176   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90177
90178   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90179   {
90180     try {
90181       delete arg1;
90182     } catch (std::out_of_range& e) {
90183       {
90184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90185       };
90186     } catch (std::exception& e) {
90187       {
90188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90189       };
90190     } catch (...) {
90191       {
90192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90193       };
90194     }
90195   }
90196 }
90197
90198
90199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90200   unsigned int jresult ;
90201   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90202   bool result;
90203
90204   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90205   {
90206     try {
90207       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90208     } catch (std::out_of_range& e) {
90209       {
90210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90211       };
90212     } catch (std::exception& e) {
90213       {
90214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90215       };
90216     } catch (...) {
90217       {
90218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90219       };
90220     }
90221   }
90222   jresult = result;
90223   return jresult;
90224 }
90225
90226
90227 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90228   unsigned long jresult ;
90229   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90230   std::size_t result;
90231
90232   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90233   {
90234     try {
90235       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90236     } catch (std::out_of_range& e) {
90237       {
90238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90239       };
90240     } catch (std::exception& e) {
90241       {
90242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90243       };
90244     } catch (...) {
90245       {
90246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90247       };
90248     }
90249   }
90250   jresult = (unsigned long)result;
90251   return jresult;
90252 }
90253
90254
90255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90256   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90257   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90258
90259   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90260   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90261   {
90262     try {
90263       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90264     } catch (std::out_of_range& e) {
90265       {
90266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90267       };
90268     } catch (std::exception& e) {
90269       {
90270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90271       };
90272     } catch (...) {
90273       {
90274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90275       };
90276     }
90277   }
90278 }
90279
90280
90281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90282   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90283   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90284
90285   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90286   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90287   {
90288     try {
90289       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90290     } catch (std::out_of_range& e) {
90291       {
90292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90293       };
90294     } catch (std::exception& e) {
90295       {
90296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90297       };
90298     } catch (...) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90301       };
90302     }
90303   }
90304 }
90305
90306
90307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90308   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90309   Dali::Vector2 *arg2 = 0 ;
90310
90311   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90312   arg2 = (Dali::Vector2 *)jarg2;
90313   if (!arg2) {
90314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90315     return ;
90316   }
90317   {
90318     try {
90319       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90320     } catch (std::out_of_range& e) {
90321       {
90322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90323       };
90324     } catch (std::exception& e) {
90325       {
90326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90327       };
90328     } catch (...) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90331       };
90332     }
90333   }
90334 }
90335
90336
90337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90338   void * jresult ;
90339   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90340
90341   {
90342     try {
90343       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90344     } catch (std::out_of_range& e) {
90345       {
90346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90347       };
90348     } catch (std::exception& e) {
90349       {
90350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (...) {
90353       {
90354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90355       };
90356     }
90357   }
90358   jresult = (void *)result;
90359   return jresult;
90360 }
90361
90362
90363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90364   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90365
90366   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90367   {
90368     try {
90369       delete arg1;
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90377       };
90378     } catch (...) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90381       };
90382     }
90383   }
90384 }
90385
90386
90387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90388   unsigned int jresult ;
90389   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90390   bool result;
90391
90392   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90393   {
90394     try {
90395       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90396     } catch (std::out_of_range& e) {
90397       {
90398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90399       };
90400     } catch (std::exception& e) {
90401       {
90402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90403       };
90404     } catch (...) {
90405       {
90406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90407       };
90408     }
90409   }
90410   jresult = result;
90411   return jresult;
90412 }
90413
90414
90415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90416   unsigned long jresult ;
90417   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90418   std::size_t result;
90419
90420   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90421   {
90422     try {
90423       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90424     } catch (std::out_of_range& e) {
90425       {
90426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (std::exception& e) {
90429       {
90430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (...) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90435       };
90436     }
90437   }
90438   jresult = (unsigned long)result;
90439   return jresult;
90440 }
90441
90442
90443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90444   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90445   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90446
90447   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90448   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90449   {
90450     try {
90451       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90452     } catch (std::out_of_range& e) {
90453       {
90454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90455       };
90456     } catch (std::exception& e) {
90457       {
90458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90459       };
90460     } catch (...) {
90461       {
90462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90463       };
90464     }
90465   }
90466 }
90467
90468
90469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90470   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90471   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90472
90473   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90474   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90475   {
90476     try {
90477       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90485       };
90486     } catch (...) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90489       };
90490     }
90491   }
90492 }
90493
90494
90495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90496   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90497   Dali::Toolkit::TextEditor arg2 ;
90498   Dali::Toolkit::TextEditor *argp2 ;
90499
90500   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90501   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90502   if (!argp2) {
90503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90504     return ;
90505   }
90506   arg2 = *argp2;
90507   {
90508     try {
90509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90510     } catch (std::out_of_range& e) {
90511       {
90512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90513       };
90514     } catch (std::exception& e) {
90515       {
90516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90517       };
90518     } catch (...) {
90519       {
90520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90521       };
90522     }
90523   }
90524 }
90525
90526
90527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90528   void * jresult ;
90529   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90530
90531   {
90532     try {
90533       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90534     } catch (std::out_of_range& e) {
90535       {
90536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90537       };
90538     } catch (std::exception& e) {
90539       {
90540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90541       };
90542     } catch (...) {
90543       {
90544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90545       };
90546     }
90547   }
90548   jresult = (void *)result;
90549   return jresult;
90550 }
90551
90552
90553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90554   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90555
90556   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90557   {
90558     try {
90559       delete arg1;
90560     } catch (std::out_of_range& e) {
90561       {
90562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90563       };
90564     } catch (std::exception& e) {
90565       {
90566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90567       };
90568     } catch (...) {
90569       {
90570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90571       };
90572     }
90573   }
90574 }
90575
90576
90577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90578   unsigned int jresult ;
90579   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90580   bool result;
90581
90582   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90583   {
90584     try {
90585       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90586     } catch (std::out_of_range& e) {
90587       {
90588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90589       };
90590     } catch (std::exception& e) {
90591       {
90592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90593       };
90594     } catch (...) {
90595       {
90596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90597       };
90598     }
90599   }
90600   jresult = result;
90601   return jresult;
90602 }
90603
90604
90605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90606   unsigned long jresult ;
90607   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90608   std::size_t result;
90609
90610   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90611   {
90612     try {
90613       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90614     } catch (std::out_of_range& e) {
90615       {
90616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90617       };
90618     } catch (std::exception& e) {
90619       {
90620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (...) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90625       };
90626     }
90627   }
90628   jresult = (unsigned long)result;
90629   return jresult;
90630 }
90631
90632
90633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90634   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90635   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90636
90637   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90638   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90639   {
90640     try {
90641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90642     } catch (std::out_of_range& e) {
90643       {
90644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90645       };
90646     } catch (std::exception& e) {
90647       {
90648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90649       };
90650     } catch (...) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90653       };
90654     }
90655   }
90656 }
90657
90658
90659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90660   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90661   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90662
90663   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90664   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90665   {
90666     try {
90667       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90668     } catch (std::out_of_range& e) {
90669       {
90670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90671       };
90672     } catch (std::exception& e) {
90673       {
90674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90675       };
90676     } catch (...) {
90677       {
90678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90679       };
90680     }
90681   }
90682 }
90683
90684
90685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90686   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90687   Dali::Toolkit::TextField arg2 ;
90688   Dali::Toolkit::TextField *argp2 ;
90689
90690   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90691   argp2 = (Dali::Toolkit::TextField *)jarg2;
90692   if (!argp2) {
90693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90694     return ;
90695   }
90696   arg2 = *argp2;
90697   {
90698     try {
90699       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90700     } catch (std::out_of_range& e) {
90701       {
90702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90703       };
90704     } catch (std::exception& e) {
90705       {
90706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90707       };
90708     } catch (...) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90711       };
90712     }
90713   }
90714 }
90715
90716
90717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90718   void * jresult ;
90719   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90720
90721   {
90722     try {
90723       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90724     } catch (std::out_of_range& e) {
90725       {
90726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (std::exception& e) {
90729       {
90730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90731       };
90732     } catch (...) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90735       };
90736     }
90737   }
90738   jresult = (void *)result;
90739   return jresult;
90740 }
90741
90742
90743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90744   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90745
90746   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90747   {
90748     try {
90749       delete arg1;
90750     } catch (std::out_of_range& e) {
90751       {
90752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90753       };
90754     } catch (std::exception& e) {
90755       {
90756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90757       };
90758     } catch (...) {
90759       {
90760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90761       };
90762     }
90763   }
90764 }
90765
90766
90767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90768   unsigned int jresult ;
90769   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90770   bool result;
90771
90772   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90773   {
90774     try {
90775       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);
90776     } catch (std::out_of_range& e) {
90777       {
90778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90779       };
90780     } catch (std::exception& e) {
90781       {
90782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90783       };
90784     } catch (...) {
90785       {
90786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90787       };
90788     }
90789   }
90790   jresult = result;
90791   return jresult;
90792 }
90793
90794
90795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90796   unsigned long jresult ;
90797   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90798   std::size_t result;
90799
90800   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90801   {
90802     try {
90803       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);
90804     } catch (std::out_of_range& e) {
90805       {
90806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90807       };
90808     } catch (std::exception& e) {
90809       {
90810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90811       };
90812     } catch (...) {
90813       {
90814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90815       };
90816     }
90817   }
90818   jresult = (unsigned long)result;
90819   return jresult;
90820 }
90821
90822
90823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90824   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90825   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90826
90827   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90828   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90829   {
90830     try {
90831       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90832     } catch (std::out_of_range& e) {
90833       {
90834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90835       };
90836     } catch (std::exception& e) {
90837       {
90838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90843       };
90844     }
90845   }
90846 }
90847
90848
90849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90850   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90851   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90852
90853   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90854   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90855   {
90856     try {
90857       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90858     } catch (std::out_of_range& e) {
90859       {
90860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90861       };
90862     } catch (std::exception& e) {
90863       {
90864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90865       };
90866     } catch (...) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90869       };
90870     }
90871   }
90872 }
90873
90874
90875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90876   unsigned int jresult ;
90877   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90878   Dali::Toolkit::Control arg2 ;
90879   Dali::KeyEvent *arg3 = 0 ;
90880   Dali::Toolkit::Control *argp2 ;
90881   bool result;
90882
90883   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90884   argp2 = (Dali::Toolkit::Control *)jarg2;
90885   if (!argp2) {
90886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90887     return 0;
90888   }
90889   arg2 = *argp2;
90890   arg3 = (Dali::KeyEvent *)jarg3;
90891   if (!arg3) {
90892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90893     return 0;
90894   }
90895   {
90896     try {
90897       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);
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (...) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90909       };
90910     }
90911   }
90912   jresult = result;
90913   return jresult;
90914 }
90915
90916
90917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90918   void * jresult ;
90919   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90920
90921   {
90922     try {
90923       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90924     } catch (std::out_of_range& e) {
90925       {
90926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90927       };
90928     } catch (std::exception& e) {
90929       {
90930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (...) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90935       };
90936     }
90937   }
90938   jresult = (void *)result;
90939   return jresult;
90940 }
90941
90942
90943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90944   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90945
90946   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90947   {
90948     try {
90949       delete arg1;
90950     } catch (std::out_of_range& e) {
90951       {
90952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90953       };
90954     } catch (std::exception& e) {
90955       {
90956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90957       };
90958     } catch (...) {
90959       {
90960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90961       };
90962     }
90963   }
90964 }
90965
90966
90967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90968   unsigned int jresult ;
90969   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90970   bool result;
90971
90972   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90973   {
90974     try {
90975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90976     } catch (std::out_of_range& e) {
90977       {
90978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (std::exception& e) {
90981       {
90982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (...) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90987       };
90988     }
90989   }
90990   jresult = result;
90991   return jresult;
90992 }
90993
90994
90995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
90996   unsigned long jresult ;
90997   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90998   std::size_t result;
90999
91000   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91001   {
91002     try {
91003       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91004     } catch (std::out_of_range& e) {
91005       {
91006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91007       };
91008     } catch (std::exception& e) {
91009       {
91010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91011       };
91012     } catch (...) {
91013       {
91014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91015       };
91016     }
91017   }
91018   jresult = (unsigned long)result;
91019   return jresult;
91020 }
91021
91022
91023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91024   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91025   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91026
91027   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91028   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91029   {
91030     try {
91031       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91032     } catch (std::out_of_range& e) {
91033       {
91034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91035       };
91036     } catch (std::exception& e) {
91037       {
91038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91039       };
91040     } catch (...) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91043       };
91044     }
91045   }
91046 }
91047
91048
91049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91050   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91051   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91052
91053   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91054   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91055   {
91056     try {
91057       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91058     } catch (std::out_of_range& e) {
91059       {
91060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91061       };
91062     } catch (std::exception& e) {
91063       {
91064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91065       };
91066     } catch (...) {
91067       {
91068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91069       };
91070     }
91071   }
91072 }
91073
91074
91075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91076   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91077   Dali::Toolkit::Control arg2 ;
91078   Dali::Toolkit::Control *argp2 ;
91079
91080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91081   argp2 = (Dali::Toolkit::Control *)jarg2;
91082   if (!argp2) {
91083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91084     return ;
91085   }
91086   arg2 = *argp2;
91087   {
91088     try {
91089       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91090     } catch (std::out_of_range& e) {
91091       {
91092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (std::exception& e) {
91095       {
91096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91101       };
91102     }
91103   }
91104 }
91105
91106
91107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91108   void * jresult ;
91109   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91110
91111   {
91112     try {
91113       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91114     } catch (std::out_of_range& e) {
91115       {
91116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91117       };
91118     } catch (std::exception& e) {
91119       {
91120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91121       };
91122     } catch (...) {
91123       {
91124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91125       };
91126     }
91127   }
91128   jresult = (void *)result;
91129   return jresult;
91130 }
91131
91132
91133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91134   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91135
91136   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91137   {
91138     try {
91139       delete arg1;
91140     } catch (std::out_of_range& e) {
91141       {
91142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91143       };
91144     } catch (std::exception& e) {
91145       {
91146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91147       };
91148     } catch (...) {
91149       {
91150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91151       };
91152     }
91153   }
91154 }
91155
91156
91157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91158   unsigned int jresult ;
91159   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91160   bool result;
91161
91162   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91163   {
91164     try {
91165       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91166     } catch (std::out_of_range& e) {
91167       {
91168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91169       };
91170     } catch (std::exception& e) {
91171       {
91172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91173       };
91174     } catch (...) {
91175       {
91176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91177       };
91178     }
91179   }
91180   jresult = result;
91181   return jresult;
91182 }
91183
91184
91185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91186   unsigned long jresult ;
91187   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91188   std::size_t result;
91189
91190   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91191   {
91192     try {
91193       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (...) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91205       };
91206     }
91207   }
91208   jresult = (unsigned long)result;
91209   return jresult;
91210 }
91211
91212
91213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91214   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91215   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91216
91217   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91218   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91219   {
91220     try {
91221       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91222     } catch (std::out_of_range& e) {
91223       {
91224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91225       };
91226     } catch (std::exception& e) {
91227       {
91228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91229       };
91230     } catch (...) {
91231       {
91232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91233       };
91234     }
91235   }
91236 }
91237
91238
91239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91240   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91241   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91242
91243   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91244   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91245   {
91246     try {
91247       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91248     } catch (std::out_of_range& e) {
91249       {
91250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91251       };
91252     } catch (std::exception& e) {
91253       {
91254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (...) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91259       };
91260     }
91261   }
91262 }
91263
91264
91265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91266   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91267   Dali::Toolkit::VideoView *arg2 = 0 ;
91268
91269   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91270   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91271   if (!arg2) {
91272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91273     return ;
91274   }
91275   {
91276     try {
91277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91278     } catch (std::out_of_range& e) {
91279       {
91280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91281       };
91282     } catch (std::exception& e) {
91283       {
91284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91285       };
91286     } catch (...) {
91287       {
91288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91289       };
91290     }
91291   }
91292 }
91293
91294
91295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91296   void * jresult ;
91297   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91298
91299   {
91300     try {
91301       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91302     } catch (std::out_of_range& e) {
91303       {
91304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91305       };
91306     } catch (std::exception& e) {
91307       {
91308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91309       };
91310     } catch (...) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91313       };
91314     }
91315   }
91316   jresult = (void *)result;
91317   return jresult;
91318 }
91319
91320
91321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91322   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91323
91324   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91325   {
91326     try {
91327       delete arg1;
91328     } catch (std::out_of_range& e) {
91329       {
91330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91331       };
91332     } catch (std::exception& e) {
91333       {
91334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91335       };
91336     } catch (...) {
91337       {
91338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91339       };
91340     }
91341   }
91342 }
91343
91344
91345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91346   unsigned int jresult ;
91347   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91348   bool result;
91349
91350   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91351   {
91352     try {
91353       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91354     } catch (std::out_of_range& e) {
91355       {
91356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91357       };
91358     } catch (std::exception& e) {
91359       {
91360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91361       };
91362     } catch (...) {
91363       {
91364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91365       };
91366     }
91367   }
91368   jresult = result;
91369   return jresult;
91370 }
91371
91372
91373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91374   unsigned long jresult ;
91375   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91376   std::size_t result;
91377
91378   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91379   {
91380     try {
91381       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91382     } catch (std::out_of_range& e) {
91383       {
91384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91385       };
91386     } catch (std::exception& e) {
91387       {
91388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91389       };
91390     } catch (...) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91393       };
91394     }
91395   }
91396   jresult = (unsigned long)result;
91397   return jresult;
91398 }
91399
91400
91401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91402   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91403   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91404
91405   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91406   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91407   {
91408     try {
91409       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91410     } catch (std::out_of_range& e) {
91411       {
91412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91413       };
91414     } catch (std::exception& e) {
91415       {
91416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91417       };
91418     } catch (...) {
91419       {
91420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91421       };
91422     }
91423   }
91424 }
91425
91426
91427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91428   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91429   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91430
91431   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91432   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91433   {
91434     try {
91435       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91436     } catch (std::out_of_range& e) {
91437       {
91438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91439       };
91440     } catch (std::exception& e) {
91441       {
91442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91443       };
91444     } catch (...) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91447       };
91448     }
91449   }
91450 }
91451
91452
91453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91454   unsigned int jresult ;
91455   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91456   Dali::Toolkit::Slider arg2 ;
91457   float arg3 ;
91458   Dali::Toolkit::Slider *argp2 ;
91459   bool result;
91460
91461   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91462   argp2 = (Dali::Toolkit::Slider *)jarg2;
91463   if (!argp2) {
91464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91465     return 0;
91466   }
91467   arg2 = *argp2;
91468   arg3 = (float)jarg3;
91469   {
91470     try {
91471       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91472     } catch (std::out_of_range& e) {
91473       {
91474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91475       };
91476     } catch (std::exception& e) {
91477       {
91478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91479       };
91480     } catch (...) {
91481       {
91482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91483       };
91484     }
91485   }
91486   jresult = result;
91487   return jresult;
91488 }
91489
91490
91491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91492   void * jresult ;
91493   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91494
91495   {
91496     try {
91497       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91498     } catch (std::out_of_range& e) {
91499       {
91500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (std::exception& e) {
91503       {
91504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91505       };
91506     } catch (...) {
91507       {
91508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91509       };
91510     }
91511   }
91512   jresult = (void *)result;
91513   return jresult;
91514 }
91515
91516
91517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91518   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91519
91520   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91521   {
91522     try {
91523       delete arg1;
91524     } catch (std::out_of_range& e) {
91525       {
91526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91527       };
91528     } catch (std::exception& e) {
91529       {
91530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91531       };
91532     } catch (...) {
91533       {
91534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91535       };
91536     }
91537   }
91538 }
91539
91540
91541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91542   unsigned int jresult ;
91543   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91544   bool result;
91545
91546   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91547   {
91548     try {
91549       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91550     } catch (std::out_of_range& e) {
91551       {
91552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91553       };
91554     } catch (std::exception& e) {
91555       {
91556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91557       };
91558     } catch (...) {
91559       {
91560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91561       };
91562     }
91563   }
91564   jresult = result;
91565   return jresult;
91566 }
91567
91568
91569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91570   unsigned long jresult ;
91571   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91572   std::size_t result;
91573
91574   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91575   {
91576     try {
91577       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91578     } catch (std::out_of_range& e) {
91579       {
91580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91581       };
91582     } catch (std::exception& e) {
91583       {
91584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91585       };
91586     } catch (...) {
91587       {
91588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91589       };
91590     }
91591   }
91592   jresult = (unsigned long)result;
91593   return jresult;
91594 }
91595
91596
91597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91598   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91599   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91600
91601   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91602   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91603   {
91604     try {
91605       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91606     } catch (std::out_of_range& e) {
91607       {
91608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91609       };
91610     } catch (std::exception& e) {
91611       {
91612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91613       };
91614     } catch (...) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91617       };
91618     }
91619   }
91620 }
91621
91622
91623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91624   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91625   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91626
91627   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91628   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91629   {
91630     try {
91631       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91639       };
91640     } catch (...) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91643       };
91644     }
91645   }
91646 }
91647
91648
91649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91650   unsigned int jresult ;
91651   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91652   Dali::Toolkit::Slider arg2 ;
91653   int arg3 ;
91654   Dali::Toolkit::Slider *argp2 ;
91655   bool result;
91656
91657   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91658   argp2 = (Dali::Toolkit::Slider *)jarg2;
91659   if (!argp2) {
91660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91661     return 0;
91662   }
91663   arg2 = *argp2;
91664   arg3 = (int)jarg3;
91665   {
91666     try {
91667       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91668     } catch (std::out_of_range& e) {
91669       {
91670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91671       };
91672     } catch (std::exception& e) {
91673       {
91674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91679       };
91680     }
91681   }
91682   jresult = result;
91683   return jresult;
91684 }
91685
91686
91687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91688   void * jresult ;
91689   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91690
91691   {
91692     try {
91693       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91694     } catch (std::out_of_range& e) {
91695       {
91696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (std::exception& e) {
91699       {
91700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91705       };
91706     }
91707   }
91708   jresult = (void *)result;
91709   return jresult;
91710 }
91711
91712
91713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91714   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91715
91716   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91717   {
91718     try {
91719       delete arg1;
91720     } catch (std::out_of_range& e) {
91721       {
91722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91723       };
91724     } catch (std::exception& e) {
91725       {
91726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91727       };
91728     } catch (...) {
91729       {
91730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91731       };
91732     }
91733   }
91734 }
91735
91736
91737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91738   void * jresult ;
91739   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91740
91741   {
91742     try {
91743       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91744     } catch (std::out_of_range& e) {
91745       {
91746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91747       };
91748     } catch (std::exception& e) {
91749       {
91750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91751       };
91752     } catch (...) {
91753       {
91754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91755       };
91756     }
91757   }
91758   jresult = (void *)result;
91759   return jresult;
91760 }
91761
91762
91763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91764   void * jresult ;
91765   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91767
91768   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91769   {
91770     try {
91771       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91772     } catch (std::out_of_range& e) {
91773       {
91774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91775       };
91776     } catch (std::exception& e) {
91777       {
91778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91779       };
91780     } catch (...) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91783       };
91784     }
91785   }
91786   jresult = (void *)result;
91787   return jresult;
91788 }
91789
91790
91791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91792   void * jresult ;
91793   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91795
91796   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91797   if (!arg1) {
91798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91799     return 0;
91800   }
91801   {
91802     try {
91803       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91804     } catch (std::out_of_range& e) {
91805       {
91806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91807       };
91808     } catch (std::exception& e) {
91809       {
91810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91811       };
91812     } catch (...) {
91813       {
91814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91815       };
91816     }
91817   }
91818   jresult = (void *)result;
91819   return jresult;
91820 }
91821
91822
91823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91825
91826   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91827   {
91828     try {
91829       delete arg1;
91830     } catch (std::out_of_range& e) {
91831       {
91832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91833       };
91834     } catch (std::exception& e) {
91835       {
91836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91837       };
91838     } catch (...) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91841       };
91842     }
91843   }
91844 }
91845
91846
91847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91848   void * jresult ;
91849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91850   Dali::Toolkit::Ruler *result = 0 ;
91851
91852   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91853   {
91854     try {
91855       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91856     } catch (std::out_of_range& e) {
91857       {
91858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91859       };
91860     } catch (std::exception& e) {
91861       {
91862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91863       };
91864     } catch (...) {
91865       {
91866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91867       };
91868     }
91869   }
91870   jresult = (void *)result;
91871   return jresult;
91872 }
91873
91874
91875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91876   void * jresult ;
91877   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91878   Dali::Toolkit::Ruler *result = 0 ;
91879
91880   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91881   {
91882     try {
91883       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (...) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91895       };
91896     }
91897   }
91898   jresult = (void *)result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91904   void * jresult ;
91905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91906   Dali::Toolkit::Ruler *result = 0 ;
91907
91908   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91909   {
91910     try {
91911       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91923       };
91924     }
91925   }
91926   jresult = (void *)result;
91927   return jresult;
91928 }
91929
91930
91931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91932   void * jresult ;
91933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91935   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91936
91937   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91938   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91939   if (!arg2) {
91940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91941     return 0;
91942   }
91943   {
91944     try {
91945       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (...) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91957       };
91958     }
91959   }
91960   jresult = (void *)result;
91961   return jresult;
91962 }
91963
91964
91965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91966   void * jresult ;
91967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91968   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91970
91971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91972   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91973   {
91974     try {
91975       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91976     } catch (std::out_of_range& e) {
91977       {
91978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91979       };
91980     } catch (std::exception& e) {
91981       {
91982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91983       };
91984     } catch (...) {
91985       {
91986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91987       };
91988     }
91989   }
91990   jresult = (void *)result;
91991   return jresult;
91992 }
91993
91994
91995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
91996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91997
91998   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91999   {
92000     try {
92001       (arg1)->Reset();
92002     } catch (std::out_of_range& e) {
92003       {
92004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92005       };
92006     } catch (std::exception& e) {
92007       {
92008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92009       };
92010     } catch (...) {
92011       {
92012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92013       };
92014     }
92015   }
92016 }
92017
92018
92019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92020   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92021   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92022
92023   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92024   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92025   {
92026     try {
92027       (arg1)->Reset(arg2);
92028     } catch (std::out_of_range& e) {
92029       {
92030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92031       };
92032     } catch (std::exception& e) {
92033       {
92034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92035       };
92036     } catch (...) {
92037       {
92038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92039       };
92040     }
92041   }
92042 }
92043
92044
92045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92046   void * jresult ;
92047   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92048   Dali::Toolkit::Ruler *result = 0 ;
92049
92050   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92051   {
92052     try {
92053       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92054     } catch (std::out_of_range& e) {
92055       {
92056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92057       };
92058     } catch (std::exception& e) {
92059       {
92060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92061       };
92062     } catch (...) {
92063       {
92064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92065       };
92066     }
92067   }
92068   jresult = (void *)result;
92069   return jresult;
92070 }
92071
92072
92073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92074   float jresult ;
92075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92076   float arg2 ;
92077   float arg3 ;
92078   float result;
92079
92080   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92081   arg2 = (float)jarg2;
92082   arg3 = (float)jarg3;
92083   {
92084     try {
92085       result = (float)(*arg1)->Snap(arg2,arg3);
92086     } catch (std::out_of_range& e) {
92087       {
92088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (std::exception& e) {
92091       {
92092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100   jresult = result;
92101   return jresult;
92102 }
92103
92104
92105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92106   float jresult ;
92107   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92108   float arg2 ;
92109   float result;
92110
92111   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92112   arg2 = (float)jarg2;
92113   {
92114     try {
92115       result = (float)(*arg1)->Snap(arg2);
92116     } catch (std::out_of_range& e) {
92117       {
92118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92119       };
92120     } catch (std::exception& e) {
92121       {
92122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92123       };
92124     } catch (...) {
92125       {
92126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92127       };
92128     }
92129   }
92130   jresult = result;
92131   return jresult;
92132 }
92133
92134
92135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92136   float jresult ;
92137   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92138   unsigned int arg2 ;
92139   unsigned int *arg3 = 0 ;
92140   bool arg4 ;
92141   float result;
92142
92143   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92144   arg2 = (unsigned int)jarg2;
92145   arg3 = (unsigned int *)jarg3;
92146   arg4 = jarg4 ? true : false;
92147   {
92148     try {
92149       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92150     } catch (std::out_of_range& e) {
92151       {
92152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92153       };
92154     } catch (std::exception& e) {
92155       {
92156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92157       };
92158     } catch (...) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92161       };
92162     }
92163   }
92164   jresult = result;
92165   return jresult;
92166 }
92167
92168
92169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92170   unsigned int jresult ;
92171   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92172   float arg2 ;
92173   bool arg3 ;
92174   unsigned int result;
92175
92176   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92177   arg2 = (float)jarg2;
92178   arg3 = jarg3 ? true : false;
92179   {
92180     try {
92181       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92182     } catch (std::out_of_range& e) {
92183       {
92184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92185       };
92186     } catch (std::exception& e) {
92187       {
92188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92189       };
92190     } catch (...) {
92191       {
92192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92193       };
92194     }
92195   }
92196   jresult = result;
92197   return jresult;
92198 }
92199
92200
92201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92202   unsigned int jresult ;
92203   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92204   unsigned int result;
92205
92206   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92207   {
92208     try {
92209       result = (unsigned int)(*arg1)->GetTotalPages();
92210     } catch (std::out_of_range& e) {
92211       {
92212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92213       };
92214     } catch (std::exception& e) {
92215       {
92216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92217       };
92218     } catch (...) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92221       };
92222     }
92223   }
92224   jresult = result;
92225   return jresult;
92226 }
92227
92228
92229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92230   int jresult ;
92231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92232   Dali::Toolkit::Ruler::RulerType result;
92233
92234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92235   {
92236     try {
92237       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (...) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92249       };
92250     }
92251   }
92252   jresult = (int)result;
92253   return jresult;
92254 }
92255
92256
92257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92258   unsigned int jresult ;
92259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92260   bool result;
92261
92262   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92263   {
92264     try {
92265       result = (bool)(*arg1)->IsEnabled();
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (...) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92277       };
92278     }
92279   }
92280   jresult = result;
92281   return jresult;
92282 }
92283
92284
92285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92286   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92287
92288   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92289   {
92290     try {
92291       (*arg1)->Enable();
92292     } catch (std::out_of_range& e) {
92293       {
92294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92295       };
92296     } catch (std::exception& e) {
92297       {
92298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92299       };
92300     } catch (...) {
92301       {
92302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92303       };
92304     }
92305   }
92306 }
92307
92308
92309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92310   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92311
92312   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92313   {
92314     try {
92315       (*arg1)->Disable();
92316     } catch (std::out_of_range& e) {
92317       {
92318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92319       };
92320     } catch (std::exception& e) {
92321       {
92322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92323       };
92324     } catch (...) {
92325       {
92326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92327       };
92328     }
92329   }
92330 }
92331
92332
92333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92334   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92335   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92336   Dali::Toolkit::RulerDomain *argp2 ;
92337
92338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92339   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92340   if (!argp2) {
92341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92342     return ;
92343   }
92344   arg2 = *argp2;
92345   {
92346     try {
92347       (*arg1)->SetDomain(arg2);
92348     } catch (std::out_of_range& e) {
92349       {
92350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92351       };
92352     } catch (std::exception& e) {
92353       {
92354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92355       };
92356     } catch (...) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92359       };
92360     }
92361   }
92362 }
92363
92364
92365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92366   void * jresult ;
92367   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92368   Dali::Toolkit::RulerDomain *result = 0 ;
92369
92370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92371   {
92372     try {
92373       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92374     } catch (std::out_of_range& e) {
92375       {
92376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92377       };
92378     } catch (std::exception& e) {
92379       {
92380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (...) {
92383       {
92384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92385       };
92386     }
92387   }
92388   jresult = (void *)result;
92389   return jresult;
92390 }
92391
92392
92393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92395
92396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92397   {
92398     try {
92399       (*arg1)->DisableDomain();
92400     } catch (std::out_of_range& e) {
92401       {
92402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92403       };
92404     } catch (std::exception& e) {
92405       {
92406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92407       };
92408     } catch (...) {
92409       {
92410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92411       };
92412     }
92413   }
92414 }
92415
92416
92417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92418   float jresult ;
92419   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92420   float arg2 ;
92421   float arg3 ;
92422   float arg4 ;
92423   float result;
92424
92425   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92426   arg2 = (float)jarg2;
92427   arg3 = (float)jarg3;
92428   arg4 = (float)jarg4;
92429   {
92430     try {
92431       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92439       };
92440     } catch (...) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92443       };
92444     }
92445   }
92446   jresult = result;
92447   return jresult;
92448 }
92449
92450
92451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92452   float jresult ;
92453   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92454   float arg2 ;
92455   float arg3 ;
92456   float result;
92457
92458   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92459   arg2 = (float)jarg2;
92460   arg3 = (float)jarg3;
92461   {
92462     try {
92463       result = (float)(*arg1)->Clamp(arg2,arg3);
92464     } catch (std::out_of_range& e) {
92465       {
92466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92467       };
92468     } catch (std::exception& e) {
92469       {
92470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92471       };
92472     } catch (...) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92475       };
92476     }
92477   }
92478   jresult = result;
92479   return jresult;
92480 }
92481
92482
92483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92484   float jresult ;
92485   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92486   float arg2 ;
92487   float result;
92488
92489   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92490   arg2 = (float)jarg2;
92491   {
92492     try {
92493       result = (float)(*arg1)->Clamp(arg2);
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (...) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92505       };
92506     }
92507   }
92508   jresult = result;
92509   return jresult;
92510 }
92511
92512
92513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92514   float jresult ;
92515   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92516   float arg2 ;
92517   float arg3 ;
92518   float arg4 ;
92519   Dali::Toolkit::ClampState *arg5 = 0 ;
92520   float result;
92521
92522   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92523   arg2 = (float)jarg2;
92524   arg3 = (float)jarg3;
92525   arg4 = (float)jarg4;
92526   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92527   if (!arg5) {
92528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92529     return 0;
92530   }
92531   {
92532     try {
92533       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92534     } catch (std::out_of_range& e) {
92535       {
92536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92537       };
92538     } catch (std::exception& e) {
92539       {
92540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92541       };
92542     } catch (...) {
92543       {
92544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92545       };
92546     }
92547   }
92548   jresult = result;
92549   return jresult;
92550 }
92551
92552
92553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92554   float jresult ;
92555   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92556   float arg2 ;
92557   float arg3 ;
92558   float arg4 ;
92559   float arg5 ;
92560   float result;
92561
92562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92563   arg2 = (float)jarg2;
92564   arg3 = (float)jarg3;
92565   arg4 = (float)jarg4;
92566   arg5 = (float)jarg5;
92567   {
92568     try {
92569       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92570     } catch (std::out_of_range& e) {
92571       {
92572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92573       };
92574     } catch (std::exception& e) {
92575       {
92576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92577       };
92578     } catch (...) {
92579       {
92580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92581       };
92582     }
92583   }
92584   jresult = result;
92585   return jresult;
92586 }
92587
92588
92589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92590   float jresult ;
92591   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92592   float arg2 ;
92593   float arg3 ;
92594   float arg4 ;
92595   float result;
92596
92597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92598   arg2 = (float)jarg2;
92599   arg3 = (float)jarg3;
92600   arg4 = (float)jarg4;
92601   {
92602     try {
92603       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92604     } catch (std::out_of_range& e) {
92605       {
92606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (std::exception& e) {
92609       {
92610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618   jresult = result;
92619   return jresult;
92620 }
92621
92622
92623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92624   float jresult ;
92625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92626   float arg2 ;
92627   float arg3 ;
92628   float result;
92629
92630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92631   arg2 = (float)jarg2;
92632   arg3 = (float)jarg3;
92633   {
92634     try {
92635       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92636     } catch (std::out_of_range& e) {
92637       {
92638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92639       };
92640     } catch (std::exception& e) {
92641       {
92642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92643       };
92644     } catch (...) {
92645       {
92646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92647       };
92648     }
92649   }
92650   jresult = result;
92651   return jresult;
92652 }
92653
92654
92655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92656   float jresult ;
92657   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92658   float arg2 ;
92659   float result;
92660
92661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92662   arg2 = (float)jarg2;
92663   {
92664     try {
92665       result = (float)(*arg1)->SnapAndClamp(arg2);
92666     } catch (std::out_of_range& e) {
92667       {
92668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92669       };
92670     } catch (std::exception& e) {
92671       {
92672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92673       };
92674     } catch (...) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92677       };
92678     }
92679   }
92680   jresult = result;
92681   return jresult;
92682 }
92683
92684
92685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92686   float jresult ;
92687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92688   float arg2 ;
92689   float arg3 ;
92690   float arg4 ;
92691   float arg5 ;
92692   Dali::Toolkit::ClampState *arg6 = 0 ;
92693   float result;
92694
92695   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92696   arg2 = (float)jarg2;
92697   arg3 = (float)jarg3;
92698   arg4 = (float)jarg4;
92699   arg5 = (float)jarg5;
92700   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92701   if (!arg6) {
92702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92703     return 0;
92704   }
92705   {
92706     try {
92707       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92708     } catch (std::out_of_range& e) {
92709       {
92710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92711       };
92712     } catch (std::exception& e) {
92713       {
92714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92715       };
92716     } catch (...) {
92717       {
92718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92719       };
92720     }
92721   }
92722   jresult = result;
92723   return jresult;
92724 }
92725
92726
92727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92729
92730   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92731   {
92732     try {
92733       (*arg1)->Reference();
92734     } catch (std::out_of_range& e) {
92735       {
92736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92737       };
92738     } catch (std::exception& e) {
92739       {
92740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92741       };
92742     } catch (...) {
92743       {
92744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92745       };
92746     }
92747   }
92748 }
92749
92750
92751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92752   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92753
92754   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92755   {
92756     try {
92757       (*arg1)->Unreference();
92758     } catch (std::out_of_range& e) {
92759       {
92760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92761       };
92762     } catch (std::exception& e) {
92763       {
92764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92765       };
92766     } catch (...) {
92767       {
92768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92769       };
92770     }
92771   }
92772 }
92773
92774
92775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92776   int jresult ;
92777   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92778   int result;
92779
92780   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92781   {
92782     try {
92783       result = (int)(*arg1)->ReferenceCount();
92784     } catch (std::out_of_range& e) {
92785       {
92786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92787       };
92788     } catch (std::exception& e) {
92789       {
92790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92791       };
92792     } catch (...) {
92793       {
92794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92795       };
92796     }
92797   }
92798   jresult = result;
92799   return jresult;
92800 }
92801
92802
92803 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92804     return (Dali::RefObject *)jarg1;
92805 }
92806
92807 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92808     return (Dali::SignalObserver *)jarg1;
92809 }
92810
92811 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92812     return (Dali::ConnectionTrackerInterface *)jarg1;
92813 }
92814
92815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92816     return (Dali::BaseHandle *)jarg1;
92817 }
92818
92819 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92820     return (Dali::BaseHandle *)jarg1;
92821 }
92822
92823 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92824     return (Dali::BaseHandle *)jarg1;
92825 }
92826
92827 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92828     return (Dali::BaseHandle *)jarg1;
92829 }
92830
92831 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92832     return (Dali::BaseHandle *)jarg1;
92833 }
92834
92835 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92836     return (Dali::BaseHandle *)jarg1;
92837 }
92838
92839 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92840     return (Dali::BaseHandle *)jarg1;
92841 }
92842
92843 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92844     return (Dali::BaseHandle *)jarg1;
92845 }
92846
92847 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92848     return (Dali::BaseHandle *)jarg1;
92849 }
92850
92851 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92852     return (Dali::BaseHandle *)jarg1;
92853 }
92854
92855 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92856     return (Dali::BaseHandle *)jarg1;
92857 }
92858
92859 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92860     return (Dali::BaseHandle *)jarg1;
92861 }
92862
92863 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92864     return (Dali::BaseHandle *)jarg1;
92865 }
92866
92867 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92868     return (Dali::Handle *)jarg1;
92869 }
92870
92871 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92872     return (Dali::Handle *)jarg1;
92873 }
92874
92875 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92876     return (Dali::BaseHandle *)jarg1;
92877 }
92878
92879 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92880     return (Dali::BaseHandle *)jarg1;
92881 }
92882
92883 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92884     return (Dali::Handle *)jarg1;
92885 }
92886
92887 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92888     return (Dali::BaseHandle *)jarg1;
92889 }
92890
92891 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92892     return (Dali::Handle *)jarg1;
92893 }
92894
92895 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92896     return (Dali::GestureDetector *)jarg1;
92897 }
92898
92899 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92900     return (Dali::Gesture *)jarg1;
92901 }
92902
92903 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92904     return (Dali::Handle *)jarg1;
92905 }
92906
92907 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92908     return (Dali::Actor *)jarg1;
92909 }
92910
92911 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92912     return (Dali::BaseHandle *)jarg1;
92913 }
92914
92915 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92916     return (Dali::RefObject *)jarg1;
92917 }
92918
92919 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92920     return (Dali::Actor *)jarg1;
92921 }
92922
92923 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92924     return (Dali::GestureDetector *)jarg1;
92925 }
92926
92927 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92928     return (Dali::Gesture *)jarg1;
92929 }
92930
92931 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92932     return (Dali::GestureDetector *)jarg1;
92933 }
92934
92935 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92936     return (Dali::Gesture *)jarg1;
92937 }
92938
92939 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92940     return (Dali::GestureDetector *)jarg1;
92941 }
92942
92943 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92944     return (Dali::Gesture *)jarg1;
92945 }
92946
92947 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92948     return (Dali::BaseHandle *)jarg1;
92949 }
92950
92951 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92952     return (Dali::Handle *)jarg1;
92953 }
92954
92955 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92956     return (Dali::BaseHandle *)jarg1;
92957 }
92958
92959 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92960     return (Dali::Handle *)jarg1;
92961 }
92962
92963 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92964     return (Dali::Handle *)jarg1;
92965 }
92966
92967 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92968     return (Dali::Image *)jarg1;
92969 }
92970
92971 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92972     return (Dali::Image *)jarg1;
92973 }
92974
92975 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92976     return (Dali::Image *)jarg1;
92977 }
92978
92979 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92980     return (Dali::RefObject *)jarg1;
92981 }
92982
92983 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92984     return (Dali::Image *)jarg1;
92985 }
92986
92987 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92988     return (Dali::Image *)jarg1;
92989 }
92990
92991 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
92992     return (Dali::ResourceImage *)jarg1;
92993 }
92994
92995 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
92996     return (Dali::Actor *)jarg1;
92997 }
92998
92999 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93000     return (Dali::BaseHandle *)jarg1;
93001 }
93002
93003 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93004     return (Dali::BaseHandle *)jarg1;
93005 }
93006
93007 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93008     return (Dali::BaseHandle *)jarg1;
93009 }
93010
93011 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93012     return (Dali::BaseHandle *)jarg1;
93013 }
93014
93015 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93016     return (Dali::BaseHandle *)jarg1;
93017 }
93018
93019 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93020     return (Dali::BaseHandle *)jarg1;
93021 }
93022
93023 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93024     return (Dali::CustomActorImpl *)jarg1;
93025 }
93026
93027 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93028     return (Dali::CustomActor *)jarg1;
93029 }
93030
93031 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93032     return (Dali::BaseHandle *)jarg1;
93033 }
93034
93035 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93036     return (Dali::Toolkit::Control *)jarg1;
93037 }
93038
93039 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93040     return (Dali::Toolkit::Control *)jarg1;
93041 }
93042
93043 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93044     return (Dali::Toolkit::Button *)jarg1;
93045 }
93046
93047 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93048     return (Dali::Toolkit::Button *)jarg1;
93049 }
93050
93051 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93052     return (Dali::Toolkit::Button *)jarg1;
93053 }
93054
93055 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93056     return (Dali::Toolkit::Control *)jarg1;
93057 }
93058
93059 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93060     return (Dali::Toolkit::Control *)jarg1;
93061 }
93062
93063 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93064     return (Dali::Toolkit::Control *)jarg1;
93065 }
93066
93067 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93068     return (Dali::Toolkit::Control *)jarg1;
93069 }
93070
93071 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93072     return (Dali::Toolkit::Control *)jarg1;
93073 }
93074
93075 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93076     return (Dali::RefObject *)jarg1;
93077 }
93078
93079 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93080     return (Dali::Toolkit::Scrollable *)jarg1;
93081 }
93082
93083 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93084     return (Dali::BaseHandle *)jarg1;
93085 }
93086
93087 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93088     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93089 }
93090
93091 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93092     return (Dali::RefObject *)jarg1;
93093 }
93094
93095 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93096     return (Dali::Toolkit::Ruler *)jarg1;
93097 }
93098
93099 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93100     return (Dali::Toolkit::Ruler *)jarg1;
93101 }
93102
93103 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93104     return (Dali::Toolkit::Scrollable *)jarg1;
93105 }
93106
93107 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93108     return (Dali::Toolkit::Control *)jarg1;
93109 }
93110
93111 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93112     return (Dali::Toolkit::Control *)jarg1;
93113 }
93114
93115 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93116     return (Dali::Toolkit::Control *)jarg1;
93117 }
93118
93119 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93120     return (Dali::Toolkit::Control *)jarg1;
93121 }
93122
93123 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93124     return (Dali::BaseHandle *)jarg1;
93125 }
93126
93127 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93128     return (Dali::BaseHandle *)jarg1;
93129 }
93130
93131 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93132     return (Dali::Toolkit::Control *)jarg1;
93133 }
93134
93135 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93136     return (Dali::Toolkit::Control *)jarg1;
93137 }
93138
93139 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93140     return (Dali::Toolkit::Control *)jarg1;
93141 }
93142
93143 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93144     return (Dali::Toolkit::Control *)jarg1;
93145 }
93146
93147 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93148     return (Dali::Toolkit::Control *)jarg1;
93149 }
93150
93151 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93152     return (Dali::Toolkit::Control *)jarg1;
93153 }
93154
93155 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93156     return (Dali::Toolkit::PageTurnView *)jarg1;
93157 }
93158
93159 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93160     return (Dali::Toolkit::PageTurnView *)jarg1;
93161 }
93162
93163 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93164     return (Dali::Toolkit::Button *)jarg1;
93165 }
93166
93167 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93168     return (Dali::BaseHandle *)jarg1;
93169 }
93170
93171 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93172     return (Dali::BaseHandle *)jarg1;
93173 }
93174
93175 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93176     return (Dali::BaseHandle *)jarg1;
93177 }
93178
93179 #ifdef __cplusplus
93180 }
93181 #endif
93182