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/scrollable/scroll-view/scroll-view-devel.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458
 459 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 460 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 461 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 462
 463 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 // add here SWIG version check
 470
 471 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 472 // disable Swig-dependent warnings
 473
 474 // 'identifier1' has C-linkage specified,
 475 // but returns UDT 'identifier2' which is incompatible with C
 476 #pragma warning(disable: 4190)
 477
 478 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 479 #pragma warning(disable: 4800)
 480
 481 // debug info too long etc etc
 482 #pragma warning(disable: 4786)
 483 #endif
 484
 485
 486 #include <stdexcept>
 487
 488
 489 #include <string>
 490
 491
 492 #include <vector>
 493 #include <algorithm>
 494 #include <stdexcept>
 495
 496
 497 #include <map>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <utility>
 503
 504
 505 typedef float floatp;
 506
 507 SWIGINTERN floatp *new_floatp(){
 508   return new float();
 509 }
 510 SWIGINTERN void delete_floatp(floatp *self){
 511   if (self) delete self;
 512 }
 513 SWIGINTERN void floatp_assign(floatp *self,float value){
 514   *self = value;
 515 }
 516 SWIGINTERN float floatp_value(floatp *self){
 517   return *self;
 518 }
 519 SWIGINTERN float *floatp_cast(floatp *self){
 520   return self;
 521 }
 522 SWIGINTERN floatp *floatp_frompointer(float *t){
 523   return (floatp *) t;
 524 }
 525
 526 typedef int intp;
 527
 528 SWIGINTERN intp *new_intp(){
 529   return new int();
 530 }
 531 SWIGINTERN void delete_intp(intp *self){
 532   if (self) delete self;
 533 }
 534 SWIGINTERN void intp_assign(intp *self,int value){
 535   *self = value;
 536 }
 537 SWIGINTERN int intp_value(intp *self){
 538   return *self;
 539 }
 540 SWIGINTERN int *intp_cast(intp *self){
 541   return self;
 542 }
 543 SWIGINTERN intp *intp_frompointer(int *t){
 544   return (intp *) t;
 545 }
 546
 547 typedef double doublep;
 548
 549 SWIGINTERN doublep *new_doublep(){
 550   return new double();
 551 }
 552 SWIGINTERN void delete_doublep(doublep *self){
 553   if (self) delete self;
 554 }
 555 SWIGINTERN void doublep_assign(doublep *self,double value){
 556   *self = value;
 557 }
 558 SWIGINTERN double doublep_value(doublep *self){
 559   return *self;
 560 }
 561 SWIGINTERN double *doublep_cast(doublep *self){
 562   return self;
 563 }
 564 SWIGINTERN doublep *doublep_frompointer(double *t){
 565   return (doublep *) t;
 566 }
 567
 568 typedef unsigned int uintp;
 569
 570 SWIGINTERN uintp *new_uintp(){
 571   return new unsigned int();
 572 }
 573 SWIGINTERN void delete_uintp(uintp *self){
 574   if (self) delete self;
 575 }
 576 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 577   *self = value;
 578 }
 579 SWIGINTERN unsigned int uintp_value(uintp *self){
 580   return *self;
 581 }
 582 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 583   return self;
 584 }
 585 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 586   return (uintp *) t;
 587 }
 588
 589 typedef unsigned short ushortp;
 590
 591 SWIGINTERN ushortp *new_ushortp(){
 592   return new unsigned short();
 593 }
 594 SWIGINTERN void delete_ushortp(ushortp *self){
 595   if (self) delete self;
 596 }
 597 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 598   *self = value;
 599 }
 600 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 601   return *self;
 602 }
 603 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 604   return self;
 605 }
 606 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 607   return (ushortp *) t;
 608 }
 609
 610 unsigned int int_to_uint(int x) {
 611    return (unsigned int) x;
 612 }
 613
 614
 615 using namespace Dali;
 616 using namespace Dali::Toolkit;
 617
 618 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 619
 620      // C++ code. DALi uses Handle <-> Body design pattern.
 621      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 622      // Handles in DALi can be converted into a boolean type
 623      // to check if the handle has a valid body attached to it.
 624      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 625      if( *self )
 626      {
 627        return true;
 628      }
 629      else
 630      {
 631        return false;
 632      }
 633     }
 634 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 635
 636      // C++ code. Check if two handles reference the same implemtion
 637      if( *self == rhs)
 638      {
 639        return true;
 640      }
 641      else
 642      {
 643        return false;
 644      }
 645     }
 646 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 647      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 648    }
 649 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){
 650      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 651    }
 652 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 653         std::vector< Dali::TouchPoint >* pv = 0;
 654         if (capacity >= 0) {
 655           pv = new std::vector< Dali::TouchPoint >();
 656           pv->reserve(capacity);
 657        } else {
 658           throw std::out_of_range("capacity");
 659        }
 660        return pv;
 661       }
 662 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 663         if (index>=0 && index<(int)self->size())
 664           return (*self)[index];
 665         else
 666           throw std::out_of_range("index");
 667       }
 668 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 669         if (index>=0 && index<(int)self->size())
 670           return (*self)[index];
 671         else
 672           throw std::out_of_range("index");
 673       }
 674 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 675         if (index>=0 && index<(int)self->size())
 676           (*self)[index] = val;
 677         else
 678           throw std::out_of_range("index");
 679       }
 680 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 681         self->insert(self->end(), values.begin(), values.end());
 682       }
 683 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 684         if (index < 0)
 685           throw std::out_of_range("index");
 686         if (count < 0)
 687           throw std::out_of_range("count");
 688         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 689           throw std::invalid_argument("invalid range");
 690         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 691       }
 692 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 693         if (index>=0 && index<(int)self->size()+1)
 694           self->insert(self->begin()+index, x);
 695         else
 696           throw std::out_of_range("index");
 697       }
 698 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 699         if (index>=0 && index<(int)self->size()+1)
 700           self->insert(self->begin()+index, values.begin(), values.end());
 701         else
 702           throw std::out_of_range("index");
 703       }
 704 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 705         if (index>=0 && index<(int)self->size())
 706           self->erase(self->begin() + index);
 707         else
 708           throw std::out_of_range("index");
 709       }
 710 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 711         if (index < 0)
 712           throw std::out_of_range("index");
 713         if (count < 0)
 714           throw std::out_of_range("count");
 715         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 716           throw std::invalid_argument("invalid range");
 717         self->erase(self->begin()+index, self->begin()+index+count);
 718       }
 719 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 720         if (count < 0)
 721           throw std::out_of_range("count");
 722         return new std::vector< Dali::TouchPoint >(count, value);
 723       }
 724 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 725         std::reverse(self->begin(), self->end());
 726       }
 727 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 728         if (index < 0)
 729           throw std::out_of_range("index");
 730         if (count < 0)
 731           throw std::out_of_range("count");
 732         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 733           throw std::invalid_argument("invalid range");
 734         std::reverse(self->begin()+index, self->begin()+index+count);
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 737         if (index < 0)
 738           throw std::out_of_range("index");
 739         if (index+values.size() > self->size())
 740           throw std::out_of_range("index");
 741         std::copy(values.begin(), values.end(), self->begin()+index);
 742       }
 743 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 744          return self->Empty();
 745       }
 746 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 747         return self->GetConnectionCount();
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 750           self->Connect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 753           self->Disconnect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 756           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 757 /*@SWIG@*/ self->Emit( arg );
 758       }
 759 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 760          return self->Empty();
 761       }
 762 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 763         return self->GetConnectionCount();
 764       }
 765 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 766           self->Connect( func );
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 769           self->Disconnect( func );
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 772           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 773 /*@SWIG@*/ self->Emit( arg );
 774       }
 775 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 776          return self->Empty();
 777       }
 778 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){
 779         return self->GetConnectionCount();
 780       }
 781 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 *)){
 782           self->Connect( func );
 783       }
 784 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 *)){
 785           self->Disconnect( func );
 786       }
 787 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){
 788           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 789 /*@SWIG@*/ self->Emit( arg );
 790       }
 791 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 792          return self->Empty();
 793       }
 794 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 795         return self->GetConnectionCount();
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 798           self->Connect( func );
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 801           self->Disconnect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 804           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 805 /*@SWIG@*/ self->Emit( arg );
 806       }
 807 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 808          return self->Empty();
 809       }
 810 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 811         return self->GetConnectionCount();
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 814           self->Connect( func );
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 817           self->Disconnect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 820           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 821 /*@SWIG@*/ self->Emit( arg );
 822       }
 823 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){
 824          return self->Empty();
 825       }
 826 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){
 827         return self->GetConnectionCount();
 828       }
 829 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 &)){
 830         self->Connect( func );
 831       }
 832 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 &)){
 833         self->Disconnect( func );
 834       }
 835 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){
 836         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 837 /*@SWIG@*/ self->Emit( arg1, arg2 );
 838       }
 839 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){
 840          return self->Empty();
 841       }
 842 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){
 843         return self->GetConnectionCount();
 844       }
 845 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 &)){
 846         self->Connect( func );
 847       }
 848 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 &)){
 849         self->Disconnect( func );
 850       }
 851 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){
 852         return self->Emit( arg1, arg2 );
 853       }
 854 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){
 855          return self->Empty();
 856       }
 857 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){
 858         return self->GetConnectionCount();
 859       }
 860 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 &)){
 861         self->Connect( func );
 862       }
 863 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 &)){
 864         self->Disconnect( func );
 865       }
 866 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){
 867         return self->Emit( arg1, arg2 );
 868       }
 869 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){
 870          return self->Empty();
 871       }
 872 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){
 873         return self->GetConnectionCount();
 874       }
 875 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 &)){
 876         self->Connect( func );
 877       }
 878 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 &)){
 879         self->Disconnect( func );
 880       }
 881 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){
 882         return self->Emit( arg1, arg2 );
 883       }
 884 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 885          return self->Empty();
 886       }
 887 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 888         return self->GetConnectionCount();
 889       }
 890 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 891           self->Connect( func );
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 894           self->Disconnect( func );
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 897           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 898 /*@SWIG@*/ self->Emit( arg );
 899       }
 900 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 901          return self->Empty();
 902       }
 903 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){
 904         return self->GetConnectionCount();
 905       }
 906 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 &)){
 907           self->Connect( func );
 908       }
 909 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 &)){
 910           self->Disconnect( func );
 911       }
 912 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){
 913           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 914 /*@SWIG@*/ self->Emit( arg );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 917          return self->Empty();
 918       }
 919 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){
 920         return self->GetConnectionCount();
 921       }
 922 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 &)){
 923           self->Connect( func );
 924       }
 925 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 &)){
 926           self->Disconnect( func );
 927       }
 928 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){
 929           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 930 /*@SWIG@*/ self->Emit( arg );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 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){
 936         return self->GetConnectionCount();
 937       }
 938 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 &)){
 939           self->Connect( func );
 940       }
 941 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 &)){
 942           self->Disconnect( func );
 943       }
 944 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){
 945           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 946 /*@SWIG@*/ self->Emit( arg );
 947       }
 948 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){
 949          return self->Empty();
 950       }
 951 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){
 952         return self->GetConnectionCount();
 953       }
 954 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 &)){
 955         self->Connect( func );
 956       }
 957 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 &)){
 958         self->Disconnect( func );
 959       }
 960 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){
 961         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg1, arg2 );
 963       }
 964 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){
 965          return self->Empty();
 966       }
 967 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){
 968         return self->GetConnectionCount();
 969       }
 970 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 &)){
 971         self->Connect( func );
 972       }
 973 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 &)){
 974         self->Disconnect( func );
 975       }
 976 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){
 977         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg1, arg2 );
 979       }
 980 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){
 981          return self->Empty();
 982       }
 983 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){
 984         return self->GetConnectionCount();
 985       }
 986 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 &)){
 987         self->Connect( func );
 988       }
 989 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 &)){
 990         self->Disconnect( func );
 991       }
 992 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){
 993         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg1, arg2 );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 997          return self->Empty();
 998       }
 999 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1000         return self->GetConnectionCount();
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1003           self->Connect( func );
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1006           self->Disconnect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1013          return self->Empty();
1014       }
1015 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1016         return self->GetConnectionCount();
1017       }
1018 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1019           self->Connect( func );
1020       }
1021 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1022           self->Disconnect( func );
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1025           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1026 /*@SWIG@*/ self->Emit( arg );
1027       }
1028
1029   // keep argcs and argv so they're always available to DALi
1030   int argC = 1;
1031   char **argV = NULL;
1032
1033 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1034          return self->Empty();
1035       }
1036 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1037         return self->GetConnectionCount();
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1040           self->Connect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1043           self->Disconnect( func );
1044       }
1045 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1046           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg );
1048       }
1049 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1050          return self->Empty();
1051       }
1052 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){
1053         return self->GetConnectionCount();
1054       }
1055 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 *)){
1056         self->Connect( func );
1057       }
1058 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 *)){
1059         self->Disconnect( func );
1060       }
1061 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){
1062         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1063 /*@SWIG@*/ self->Emit( arg1, arg2 );
1064       }
1065 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1066          return self->Empty();
1067       }
1068 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1069         return self->GetConnectionCount();
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1072           self->Connect( func );
1073       }
1074 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1075           self->Disconnect( func );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1078           return self->Emit();
1079       }
1080 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1087           self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1093           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1094 /*@SWIG@*/ self->Emit( arg );
1095       }
1096 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1097         std::vector< unsigned int >* pv = 0;
1098         if (capacity >= 0) {
1099           pv = new std::vector< unsigned int >();
1100           pv->reserve(capacity);
1101        } else {
1102           throw std::out_of_range("capacity");
1103        }
1104        return pv;
1105       }
1106 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1107         if (index>=0 && index<(int)self->size())
1108           return (*self)[index];
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1119         if (index>=0 && index<(int)self->size())
1120           (*self)[index] = val;
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1125         self->insert(self->end(), values.begin(), values.end());
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1128         if (index < 0)
1129           throw std::out_of_range("index");
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1133           throw std::invalid_argument("invalid range");
1134         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1137         if (index>=0 && index<(int)self->size()+1)
1138           self->insert(self->begin()+index, x);
1139         else
1140           throw std::out_of_range("index");
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, values.begin(), values.end());
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1149         if (index>=0 && index<(int)self->size())
1150           self->erase(self->begin() + index);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         self->erase(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         return new std::vector< unsigned int >(count, value);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1169         std::reverse(self->begin(), self->end());
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         std::reverse(self->begin()+index, self->begin()+index+count);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (index+values.size() > self->size())
1184           throw std::out_of_range("index");
1185         std::copy(values.begin(), values.end(), self->begin()+index);
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1188         return std::find(self->begin(), self->end(), value) != self->end();
1189       }
1190 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1191         int index = -1;
1192         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1193         if (it != self->end())
1194           index = (int)(it - self->begin());
1195         return index;
1196       }
1197 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1198         int index = -1;
1199         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1200         if (rit != self->rend())
1201           index = (int)(self->rend() - 1 - rit);
1202         return index;
1203       }
1204 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end()) {
1207           self->erase(it);
1208           return true;
1209         }
1210         return false;
1211       }
1212 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){
1213         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1214         if (capacity >= 0) {
1215           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1216           pv->reserve(capacity);
1217        } else {
1218           throw std::out_of_range("capacity");
1219        }
1220        return pv;
1221       }
1222 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){
1223         if (index>=0 && index<(int)self->size())
1224           return (*self)[index];
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1235         if (index>=0 && index<(int)self->size())
1236           (*self)[index] = val;
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         self->insert(self->end(), values.begin(), values.end());
1242       }
1243 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1244         if (index < 0)
1245           throw std::out_of_range("index");
1246         if (count < 0)
1247           throw std::out_of_range("count");
1248         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1249           throw std::invalid_argument("invalid range");
1250         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1251       }
1252 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){
1253         if (index>=0 && index<(int)self->size()+1)
1254           self->insert(self->begin()+index, x);
1255         else
1256           throw std::out_of_range("index");
1257       }
1258 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){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, values.begin(), values.end());
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 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){
1265         if (index>=0 && index<(int)self->size())
1266           self->erase(self->begin() + index);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 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){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         self->erase(self->begin()+index, self->begin()+index+count);
1278       }
1279 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){
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1283       }
1284 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){
1285         std::reverse(self->begin(), self->end());
1286       }
1287 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){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         std::reverse(self->begin()+index, self->begin()+index+count);
1295       }
1296 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){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (index+values.size() > self->size())
1300           throw std::out_of_range("index");
1301         std::copy(values.begin(), values.end(), self->begin()+index);
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1304         std::vector< Dali::Actor >* pv = 0;
1305         if (capacity >= 0) {
1306           pv = new std::vector< Dali::Actor >();
1307           pv->reserve(capacity);
1308        } else {
1309           throw std::out_of_range("capacity");
1310        }
1311        return pv;
1312       }
1313 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1314         if (index>=0 && index<(int)self->size())
1315           return (*self)[index];
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1326         if (index>=0 && index<(int)self->size())
1327           (*self)[index] = val;
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1332         self->insert(self->end(), values.begin(), values.end());
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1335         if (index < 0)
1336           throw std::out_of_range("index");
1337         if (count < 0)
1338           throw std::out_of_range("count");
1339         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1340           throw std::invalid_argument("invalid range");
1341         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1344         if (index>=0 && index<(int)self->size()+1)
1345           self->insert(self->begin()+index, x);
1346         else
1347           throw std::out_of_range("index");
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, values.begin(), values.end());
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1356         if (index>=0 && index<(int)self->size())
1357           self->erase(self->begin() + index);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         self->erase(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         return new std::vector< Dali::Actor >(count, value);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1376         std::reverse(self->begin(), self->end());
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1379         if (index < 0)
1380           throw std::out_of_range("index");
1381         if (count < 0)
1382           throw std::out_of_range("count");
1383         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1384           throw std::invalid_argument("invalid range");
1385         std::reverse(self->begin()+index, self->begin()+index+count);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (index+values.size() > self->size())
1391           throw std::out_of_range("index");
1392         std::copy(values.begin(), values.end(), self->begin()+index);
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 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 &)){
1401           self->Connect( func );
1402       }
1403 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 &)){
1404           self->Disconnect( func );
1405       }
1406 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){
1407           return self->Emit( arg );
1408       }
1409 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){
1410          return self->Empty();
1411       }
1412 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){
1413         return self->GetConnectionCount();
1414       }
1415 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)){
1416         self->Connect( func );
1417       }
1418 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)){
1419         self->Disconnect( func );
1420       }
1421 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){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1426          return self->Empty();
1427       }
1428 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){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432         self->Connect( func );
1433       }
1434 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)){
1435         self->Disconnect( func );
1436       }
1437 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){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448         self->Connect( func );
1449       }
1450 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)){
1451         self->Disconnect( func );
1452       }
1453 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){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 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){
1458          return self->Empty();
1459       }
1460 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){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464         self->Connect( func );
1465       }
1466 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)){
1467         self->Disconnect( func );
1468       }
1469 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){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1486           return self->Emit( arg );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 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)){
1495           self->Connect( func );
1496       }
1497 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)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 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){
1505          return self->Empty();
1506       }
1507 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){
1508         return self->GetConnectionCount();
1509       }
1510 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)){
1511           return self->Connect( func );
1512       }
1513 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)){
1514           self->Disconnect( func );
1515       }
1516 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){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 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)){
1527           self->Connect( func );
1528       }
1529 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)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 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){
1537          return self->Empty();
1538       }
1539 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){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           return self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 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){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 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){
1553          return self->Empty();
1554       }
1555 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){
1556         return self->GetConnectionCount();
1557       }
1558 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 &)){
1559           self->Connect( func );
1560       }
1561 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 &)){
1562           self->Disconnect( func );
1563       }
1564 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){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575           self->Connect( func );
1576       }
1577 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 &)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1585          return self->Empty();
1586       }
1587 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1588         return self->GetConnectionCount();
1589       }
1590 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)){
1591           self->Connect( func );
1592       }
1593 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)){
1594           self->Disconnect( func );
1595       }
1596 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1601          return self->Empty();
1602       }
1603 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1604         return self->GetConnectionCount();
1605       }
1606 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)){
1607           self->Connect( func );
1608       }
1609 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)){
1610           self->Disconnect( func );
1611       }
1612 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1613           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1614 /*@SWIG@*/ self->Emit( arg );
1615       }
1616 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){
1617          return self->Empty();
1618       }
1619 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){
1620         return self->GetConnectionCount();
1621       }
1622 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 &)){
1623         self->Connect( func );
1624       }
1625 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 &)){
1626         self->Disconnect( func );
1627       }
1628 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){
1629         return self->Emit( arg1, arg2 );
1630       }
1631 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632          return self->Empty();
1633       }
1634 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1635         return self->GetConnectionCount();
1636       }
1637 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)){
1638           self->Connect( func );
1639       }
1640 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)){
1641           self->Disconnect( func );
1642       }
1643 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1644           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1645 /*@SWIG@*/ self->Emit( arg );
1646       }
1647 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648          return self->Empty();
1649       }
1650 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1651         return self->GetConnectionCount();
1652       }
1653 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 &)){
1654           self->Connect( func );
1655       }
1656 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 &)){
1657           self->Disconnect( func );
1658       }
1659 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){
1660           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1661 /*@SWIG@*/ self->Emit( arg );
1662       }
1663 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1664          return self->Empty();
1665       }
1666 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){
1667         return self->GetConnectionCount();
1668       }
1669 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)){
1670         self->Connect( func );
1671       }
1672 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)){
1673         self->Disconnect( func );
1674       }
1675 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){
1676         return self->Emit( arg1, arg2 );
1677       }
1678 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1679          return self->Empty();
1680       }
1681 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){
1682         return self->GetConnectionCount();
1683       }
1684 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)){
1685         self->Connect( func );
1686       }
1687 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)){
1688         self->Disconnect( func );
1689       }
1690 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){
1691         return self->Emit( arg1, arg2 );
1692       }
1693
1694
1695 /* ---------------------------------------------------
1696  * C++ director class methods
1697  * --------------------------------------------------- */
1698
1699 #include "dali_wrap.h"
1700
1701 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1702   swig_init_callbacks();
1703 }
1704
1705 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1706
1707 }
1708
1709
1710 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1711   int jdepth  ;
1712
1713   if (!swig_callbackOnStageConnection) {
1714     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1715     return;
1716   } else {
1717     jdepth = depth;
1718     swig_callbackOnStageConnection(jdepth);
1719   }
1720 }
1721
1722 void SwigDirector_ViewImpl::OnStageDisconnection() {
1723   if (!swig_callbackOnStageDisconnection) {
1724     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1725     return;
1726   } else {
1727     swig_callbackOnStageDisconnection();
1728   }
1729 }
1730
1731 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1732   void * jchild = 0 ;
1733
1734   if (!swig_callbackOnChildAdd) {
1735     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1736     return;
1737   } else {
1738     jchild = (Dali::Actor *) &child;
1739     swig_callbackOnChildAdd(jchild);
1740   }
1741 }
1742
1743 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1744   void * jchild = 0 ;
1745
1746   if (!swig_callbackOnChildRemove) {
1747     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1748     return;
1749   } else {
1750     jchild = (Dali::Actor *) &child;
1751     swig_callbackOnChildRemove(jchild);
1752   }
1753 }
1754
1755 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1756   int jindex  ;
1757   void * jpropertyValue  ;
1758
1759   if (!swig_callbackOnPropertySet) {
1760     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1761     return;
1762   } else {
1763     jindex = index;
1764     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1765     swig_callbackOnPropertySet(jindex, jpropertyValue);
1766   }
1767 }
1768
1769 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1770   void * jtargetSize = 0 ;
1771
1772   if (!swig_callbackOnSizeSet) {
1773     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1774     return;
1775   } else {
1776     jtargetSize = (Dali::Vector3 *) &targetSize;
1777     swig_callbackOnSizeSet(jtargetSize);
1778   }
1779 }
1780
1781 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1782   void * janimation = 0 ;
1783   void * jtargetSize = 0 ;
1784
1785   if (!swig_callbackOnSizeAnimation) {
1786     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1787     return;
1788   } else {
1789     janimation = (Dali::Animation *) &animation;
1790     jtargetSize = (Dali::Vector3 *) &targetSize;
1791     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1792   }
1793 }
1794
1795 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1796   bool c_result = SwigValueInit< bool >() ;
1797   unsigned int jresult = 0 ;
1798   void * jarg0 = 0 ;
1799
1800   if (!swig_callbackOnTouchEvent) {
1801     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1802   } else {
1803     jarg0 = (Dali::TouchEvent *) &event;
1804     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1805     c_result = jresult ? true : false;
1806   }
1807   return c_result;
1808 }
1809
1810 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1811   bool c_result = SwigValueInit< bool >() ;
1812   unsigned int jresult = 0 ;
1813   void * jarg0 = 0 ;
1814
1815   if (!swig_callbackOnHoverEvent) {
1816     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1817   } else {
1818     jarg0 = (Dali::HoverEvent *) &event;
1819     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1820     c_result = jresult ? true : false;
1821   }
1822   return c_result;
1823 }
1824
1825 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1826   bool c_result = SwigValueInit< bool >() ;
1827   unsigned int jresult = 0 ;
1828   void * jarg0 = 0 ;
1829
1830   if (!swig_callbackOnKeyEvent) {
1831     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1832   } else {
1833     jarg0 = (Dali::KeyEvent *) &event;
1834     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1835     c_result = jresult ? true : false;
1836   }
1837   return c_result;
1838 }
1839
1840 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1841   bool c_result = SwigValueInit< bool >() ;
1842   unsigned int jresult = 0 ;
1843   void * jarg0 = 0 ;
1844
1845   if (!swig_callbackOnWheelEvent) {
1846     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1847   } else {
1848     jarg0 = (Dali::WheelEvent *) &event;
1849     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1850     c_result = jresult ? true : false;
1851   }
1852   return c_result;
1853 }
1854
1855 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1856   void * jsize = 0 ;
1857   void * jcontainer = 0 ;
1858
1859   if (!swig_callbackOnRelayout) {
1860     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1861     return;
1862   } else {
1863     jsize = (Dali::Vector2 *) &size;
1864     jcontainer = (Dali::RelayoutContainer *) &container;
1865     swig_callbackOnRelayout(jsize, jcontainer);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1870   int jpolicy  ;
1871   int jdimension  ;
1872
1873   if (!swig_callbackOnSetResizePolicy) {
1874     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1875     return;
1876   } else {
1877     jpolicy = (int)policy;
1878     jdimension = (int)dimension;
1879     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1880   }
1881 }
1882
1883 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1884   Dali::Vector3 c_result ;
1885   void * jresult = 0 ;
1886
1887   if (!swig_callbackGetNaturalSize) {
1888     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1889   } else {
1890     jresult = (void *) swig_callbackGetNaturalSize();
1891     if (!jresult) {
1892       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1893       return c_result;
1894     }
1895     c_result = *(Dali::Vector3 *)jresult;
1896   }
1897   return c_result;
1898 }
1899
1900 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1901   float c_result = SwigValueInit< float >() ;
1902   float jresult = 0 ;
1903   void * jchild = 0 ;
1904   int jdimension  ;
1905
1906   if (!swig_callbackCalculateChildSize) {
1907     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1908   } else {
1909     jchild = (Dali::Actor *) &child;
1910     jdimension = (int)dimension;
1911     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1912     c_result = (float)jresult;
1913   }
1914   return c_result;
1915 }
1916
1917 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1918   float c_result = SwigValueInit< float >() ;
1919   float jresult = 0 ;
1920   float jwidth  ;
1921
1922   if (!swig_callbackGetHeightForWidth) {
1923     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1924   } else {
1925     jwidth = width;
1926     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1927     c_result = (float)jresult;
1928   }
1929   return c_result;
1930 }
1931
1932 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1933   float c_result = SwigValueInit< float >() ;
1934   float jresult = 0 ;
1935   float jheight  ;
1936
1937   if (!swig_callbackGetWidthForHeight) {
1938     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1939   } else {
1940     jheight = height;
1941     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1942     c_result = (float)jresult;
1943   }
1944   return c_result;
1945 }
1946
1947 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1948   bool c_result = SwigValueInit< bool >() ;
1949   unsigned int jresult = 0 ;
1950   int jdimension  ;
1951
1952   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1953     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1954   } else {
1955     jdimension = (int)dimension;
1956     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1957     c_result = jresult ? true : false;
1958   }
1959   return c_result;
1960 }
1961
1962 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1963   int jdimension  ;
1964
1965   if (!swig_callbackOnCalculateRelayoutSize) {
1966     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1967     return;
1968   } else {
1969     jdimension = (int)dimension;
1970     swig_callbackOnCalculateRelayoutSize(jdimension);
1971   }
1972 }
1973
1974 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1975   float jsize  ;
1976   int jdimension  ;
1977
1978   if (!swig_callbackOnLayoutNegotiated) {
1979     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1980     return;
1981   } else {
1982     jsize = size;
1983     jdimension = (int)dimension;
1984     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1985   }
1986 }
1987
1988 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1989   return Dali::CustomActorImpl::GetExtension();
1990 }
1991
1992 void SwigDirector_ViewImpl::OnInitialize() {
1993   if (!swig_callbackOnInitialize) {
1994     Dali::Toolkit::Internal::Control::OnInitialize();
1995     return;
1996   } else {
1997     swig_callbackOnInitialize();
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2002   void * jchild = 0 ;
2003
2004   if (!swig_callbackOnControlChildAdd) {
2005     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2006     return;
2007   } else {
2008     jchild = (Dali::Actor *) &child;
2009     swig_callbackOnControlChildAdd(jchild);
2010   }
2011 }
2012
2013 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2014   void * jchild = 0 ;
2015
2016   if (!swig_callbackOnControlChildRemove) {
2017     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2018     return;
2019   } else {
2020     jchild = (Dali::Actor *) &child;
2021     swig_callbackOnControlChildRemove(jchild);
2022   }
2023 }
2024
2025 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2026   void * jstyleManager  ;
2027   int jchange  ;
2028
2029   if (!swig_callbackOnStyleChange) {
2030     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2031     return;
2032   } else {
2033     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2034     jchange = (int)change;
2035     swig_callbackOnStyleChange(jstyleManager, jchange);
2036   }
2037 }
2038
2039 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2040   bool c_result = SwigValueInit< bool >() ;
2041   unsigned int jresult = 0 ;
2042
2043   if (!swig_callbackOnAccessibilityActivated) {
2044     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2045   } else {
2046     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2047     c_result = jresult ? true : false;
2048   }
2049   return c_result;
2050 }
2051
2052 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2053   bool c_result = SwigValueInit< bool >() ;
2054   unsigned int jresult = 0 ;
2055   void * jgesture  ;
2056
2057   if (!swig_callbackOnAccessibilityPan) {
2058     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2059   } else {
2060     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2061     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2062     c_result = jresult ? true : false;
2063   }
2064   return c_result;
2065 }
2066
2067 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2068   bool c_result = SwigValueInit< bool >() ;
2069   unsigned int jresult = 0 ;
2070   void * jtouchEvent = 0 ;
2071
2072   if (!swig_callbackOnAccessibilityTouch) {
2073     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2074   } else {
2075     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2076     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2077     c_result = jresult ? true : false;
2078   }
2079   return c_result;
2080 }
2081
2082 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2083   bool c_result = SwigValueInit< bool >() ;
2084   unsigned int jresult = 0 ;
2085   unsigned int jisIncrease  ;
2086
2087   if (!swig_callbackOnAccessibilityValueChange) {
2088     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2089   } else {
2090     jisIncrease = isIncrease;
2091     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2092     c_result = jresult ? true : false;
2093   }
2094   return c_result;
2095 }
2096
2097 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2098   bool c_result = SwigValueInit< bool >() ;
2099   unsigned int jresult = 0 ;
2100
2101   if (!swig_callbackOnAccessibilityZoom) {
2102     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2103   } else {
2104     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2105     c_result = jresult ? true : false;
2106   }
2107   return c_result;
2108 }
2109
2110 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2111   if (!swig_callbackOnKeyInputFocusGained) {
2112     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2113     return;
2114   } else {
2115     swig_callbackOnKeyInputFocusGained();
2116   }
2117 }
2118
2119 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2120   if (!swig_callbackOnKeyInputFocusLost) {
2121     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2122     return;
2123   } else {
2124     swig_callbackOnKeyInputFocusLost();
2125   }
2126 }
2127
2128 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2129   Dali::Actor c_result ;
2130   void * jresult = 0 ;
2131   void * jcurrentFocusedActor  ;
2132   int jdirection  ;
2133   unsigned int jloopEnabled  ;
2134
2135   if (!swig_callbackGetNextKeyboardFocusableActor) {
2136     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2137   } else {
2138     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2139     jdirection = (int)direction;
2140     jloopEnabled = loopEnabled;
2141     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2142     if (!jresult) {
2143       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2144       return c_result;
2145     }
2146     c_result = *(Dali::Actor *)jresult;
2147   }
2148   return c_result;
2149 }
2150
2151 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2152   void * jcommitedFocusableActor  ;
2153
2154   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2155     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2156     return;
2157   } else {
2158     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2159     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2160   }
2161 }
2162
2163 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2164   bool c_result = SwigValueInit< bool >() ;
2165   unsigned int jresult = 0 ;
2166
2167   if (!swig_callbackOnKeyboardEnter) {
2168     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2169   } else {
2170     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2171     c_result = jresult ? true : false;
2172   }
2173   return c_result;
2174 }
2175
2176 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2177   void * jpinch = 0 ;
2178
2179   if (!swig_callbackOnPinch) {
2180     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2181     return;
2182   } else {
2183     jpinch = (Dali::PinchGesture *) &pinch;
2184     swig_callbackOnPinch(jpinch);
2185   }
2186 }
2187
2188 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2189   void * jpan = 0 ;
2190
2191   if (!swig_callbackOnPan) {
2192     Dali::Toolkit::Internal::Control::OnPan(pan);
2193     return;
2194   } else {
2195     jpan = (Dali::PanGesture *) &pan;
2196     swig_callbackOnPan(jpan);
2197   }
2198 }
2199
2200 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2201   void * jtap = 0 ;
2202
2203   if (!swig_callbackOnTap) {
2204     Dali::Toolkit::Internal::Control::OnTap(tap);
2205     return;
2206   } else {
2207     jtap = (Dali::TapGesture *) &tap;
2208     swig_callbackOnTap(jtap);
2209   }
2210 }
2211
2212 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2213   void * jlongPress = 0 ;
2214
2215   if (!swig_callbackOnLongPress) {
2216     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2217     return;
2218   } else {
2219     jlongPress = (Dali::LongPressGesture *) &longPress;
2220     swig_callbackOnLongPress(jlongPress);
2221   }
2222 }
2223
2224 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2225   void * jslotObserver = 0 ;
2226   void * jcallback = 0 ;
2227
2228   if (!swig_callbackSignalConnected) {
2229     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2230     return;
2231   } else {
2232     jslotObserver = (void *) slotObserver;
2233     jcallback = (void *) callback;
2234     swig_callbackSignalConnected(jslotObserver, jcallback);
2235   }
2236 }
2237
2238 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2239   void * jslotObserver = 0 ;
2240   void * jcallback = 0 ;
2241
2242   if (!swig_callbackSignalDisconnected) {
2243     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2244     return;
2245   } else {
2246     jslotObserver = (void *) slotObserver;
2247     jcallback = (void *) callback;
2248     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2249   }
2250 }
2251
2252 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2253   return Dali::Toolkit::Internal::Control::GetControlExtension();
2254 }
2255
2256 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) {
2257   swig_callbackOnStageConnection = callbackOnStageConnection;
2258   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2259   swig_callbackOnChildAdd = callbackOnChildAdd;
2260   swig_callbackOnChildRemove = callbackOnChildRemove;
2261   swig_callbackOnPropertySet = callbackOnPropertySet;
2262   swig_callbackOnSizeSet = callbackOnSizeSet;
2263   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2264   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2265   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2266   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2267   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2268   swig_callbackOnRelayout = callbackOnRelayout;
2269   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2270   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2271   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2272   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2273   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2274   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2275   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2276   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2277   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2278   swig_callbackOnInitialize = callbackOnInitialize;
2279   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2280   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2281   swig_callbackOnStyleChange = callbackOnStyleChange;
2282   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2283   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2284   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2285   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2286   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2287   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2288   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2289   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2290   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2291   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2292   swig_callbackOnPinch = callbackOnPinch;
2293   swig_callbackOnPan = callbackOnPan;
2294   swig_callbackOnTap = callbackOnTap;
2295   swig_callbackOnLongPress = callbackOnLongPress;
2296   swig_callbackSignalConnected = callbackSignalConnected;
2297   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2298 }
2299
2300 void SwigDirector_ViewImpl::swig_init_callbacks() {
2301   swig_callbackOnStageConnection = 0;
2302   swig_callbackOnStageDisconnection = 0;
2303   swig_callbackOnChildAdd = 0;
2304   swig_callbackOnChildRemove = 0;
2305   swig_callbackOnPropertySet = 0;
2306   swig_callbackOnSizeSet = 0;
2307   swig_callbackOnSizeAnimation = 0;
2308   swig_callbackOnTouchEvent = 0;
2309   swig_callbackOnHoverEvent = 0;
2310   swig_callbackOnKeyEvent = 0;
2311   swig_callbackOnWheelEvent = 0;
2312   swig_callbackOnRelayout = 0;
2313   swig_callbackOnSetResizePolicy = 0;
2314   swig_callbackGetNaturalSize = 0;
2315   swig_callbackCalculateChildSize = 0;
2316   swig_callbackGetHeightForWidth = 0;
2317   swig_callbackGetWidthForHeight = 0;
2318   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2319   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2320   swig_callbackOnCalculateRelayoutSize = 0;
2321   swig_callbackOnLayoutNegotiated = 0;
2322   swig_callbackOnInitialize = 0;
2323   swig_callbackOnControlChildAdd = 0;
2324   swig_callbackOnControlChildRemove = 0;
2325   swig_callbackOnStyleChange = 0;
2326   swig_callbackOnAccessibilityActivated = 0;
2327   swig_callbackOnAccessibilityPan = 0;
2328   swig_callbackOnAccessibilityTouch = 0;
2329   swig_callbackOnAccessibilityValueChange = 0;
2330   swig_callbackOnAccessibilityZoom = 0;
2331   swig_callbackOnKeyInputFocusGained = 0;
2332   swig_callbackOnKeyInputFocusLost = 0;
2333   swig_callbackGetNextKeyboardFocusableActor = 0;
2334   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2335   swig_callbackOnKeyboardEnter = 0;
2336   swig_callbackOnPinch = 0;
2337   swig_callbackOnPan = 0;
2338   swig_callbackOnTap = 0;
2339   swig_callbackOnLongPress = 0;
2340   swig_callbackSignalConnected = 0;
2341   swig_callbackSignalDisconnected = 0;
2342 }
2343
2344 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2345   swig_init_callbacks();
2346 }
2347
2348 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2349
2350 }
2351
2352
2353 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2354   unsigned int c_result = SwigValueInit< unsigned int >() ;
2355   unsigned int jresult = 0 ;
2356
2357   if (!swig_callbackGetNumberOfItems) {
2358     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2359   } else {
2360     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2361     c_result = (unsigned int)jresult;
2362   }
2363   return c_result;
2364 }
2365
2366 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2367   Dali::Actor c_result ;
2368   void * jresult = 0 ;
2369   unsigned int jitemId  ;
2370
2371   if (!swig_callbackNewItem) {
2372     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2373   } else {
2374     jitemId = itemId;
2375     jresult = (void *) swig_callbackNewItem(jitemId);
2376     if (!jresult) {
2377       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2378       return c_result;
2379     }
2380     c_result = *(Dali::Actor *)jresult;
2381   }
2382   return c_result;
2383 }
2384
2385 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2386   unsigned int jitemId  ;
2387   void * jactor  ;
2388
2389   if (!swig_callbackItemReleased) {
2390     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2391     return;
2392   } else {
2393     jitemId = itemId;
2394     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2395     swig_callbackItemReleased(jitemId, jactor);
2396   }
2397 }
2398
2399 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2400   return Dali::Toolkit::ItemFactory::GetExtension();
2401 }
2402
2403 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2404   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2405   swig_callbackNewItem = callbackNewItem;
2406   swig_callbackItemReleased = callbackItemReleased;
2407 }
2408
2409 void SwigDirector_ItemFactory::swig_init_callbacks() {
2410   swig_callbackGetNumberOfItems = 0;
2411   swig_callbackNewItem = 0;
2412   swig_callbackItemReleased = 0;
2413 }
2414
2415 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2416   swig_init_callbacks();
2417 }
2418
2419 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2420
2421 }
2422
2423
2424 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2425   Dali::Actor c_result ;
2426   void * jresult = 0 ;
2427   void * jcurrent  ;
2428   void * jproposed  ;
2429   int jdirection  ;
2430
2431   if (!swig_callbackGetNextFocusableActor) {
2432     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2433   } else {
2434     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2435     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2436     jdirection = (int)direction;
2437     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2438     if (!jresult) {
2439       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2440       return c_result;
2441     }
2442     c_result = *(Dali::Actor *)jresult;
2443   }
2444   return c_result;
2445 }
2446
2447 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2448   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2449 }
2450
2451 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2452   swig_callbackGetNextFocusableActor = 0;
2453 }
2454
2455
2456 #ifdef __cplusplus
2457 extern "C" {
2458 #endif
2459
2460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2461   void * jresult ;
2462   floatp *result = 0 ;
2463
2464   {
2465     try {
2466       result = (floatp *)new_floatp();
2467     } catch (std::out_of_range& e) {
2468       {
2469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2470       };
2471     } catch (std::exception& e) {
2472       {
2473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2474       };
2475     } catch (...) {
2476       {
2477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2478       };
2479     }
2480   }
2481   jresult = (void *)result;
2482   return jresult;
2483 }
2484
2485
2486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2487   floatp *arg1 = (floatp *) 0 ;
2488
2489   arg1 = (floatp *)jarg1;
2490   {
2491     try {
2492       delete_floatp(arg1);
2493     } catch (std::out_of_range& e) {
2494       {
2495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2496       };
2497     } catch (std::exception& e) {
2498       {
2499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2500       };
2501     } catch (...) {
2502       {
2503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2504       };
2505     }
2506   }
2507 }
2508
2509
2510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2511   floatp *arg1 = (floatp *) 0 ;
2512   float arg2 ;
2513
2514   arg1 = (floatp *)jarg1;
2515   arg2 = (float)jarg2;
2516   {
2517     try {
2518       floatp_assign(arg1,arg2);
2519     } catch (std::out_of_range& e) {
2520       {
2521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2522       };
2523     } catch (std::exception& e) {
2524       {
2525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2526       };
2527     } catch (...) {
2528       {
2529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2530       };
2531     }
2532   }
2533 }
2534
2535
2536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2537   float jresult ;
2538   floatp *arg1 = (floatp *) 0 ;
2539   float result;
2540
2541   arg1 = (floatp *)jarg1;
2542   {
2543     try {
2544       result = (float)floatp_value(arg1);
2545     } catch (std::out_of_range& e) {
2546       {
2547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2548       };
2549     } catch (std::exception& e) {
2550       {
2551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (...) {
2554       {
2555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2556       };
2557     }
2558   }
2559   jresult = result;
2560   return jresult;
2561 }
2562
2563
2564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2565   void * jresult ;
2566   floatp *arg1 = (floatp *) 0 ;
2567   float *result = 0 ;
2568
2569   arg1 = (floatp *)jarg1;
2570   {
2571     try {
2572       result = (float *)floatp_cast(arg1);
2573     } catch (std::out_of_range& e) {
2574       {
2575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2576       };
2577     } catch (std::exception& e) {
2578       {
2579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2580       };
2581     } catch (...) {
2582       {
2583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2584       };
2585     }
2586   }
2587   jresult = (void *)result;
2588   return jresult;
2589 }
2590
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2593   void * jresult ;
2594   float *arg1 = (float *) 0 ;
2595   floatp *result = 0 ;
2596
2597   arg1 = (float *)jarg1;
2598   {
2599     try {
2600       result = (floatp *)floatp_frompointer(arg1);
2601     } catch (std::out_of_range& e) {
2602       {
2603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (std::exception& e) {
2606       {
2607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2621   void * jresult ;
2622   intp *result = 0 ;
2623
2624   {
2625     try {
2626       result = (intp *)new_intp();
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2638       };
2639     }
2640   }
2641   jresult = (void *)result;
2642   return jresult;
2643 }
2644
2645
2646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2647   intp *arg1 = (intp *) 0 ;
2648
2649   arg1 = (intp *)jarg1;
2650   {
2651     try {
2652       delete_intp(arg1);
2653     } catch (std::out_of_range& e) {
2654       {
2655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2656       };
2657     } catch (std::exception& e) {
2658       {
2659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (...) {
2662       {
2663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2664       };
2665     }
2666   }
2667 }
2668
2669
2670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2671   intp *arg1 = (intp *) 0 ;
2672   int arg2 ;
2673
2674   arg1 = (intp *)jarg1;
2675   arg2 = (int)jarg2;
2676   {
2677     try {
2678       intp_assign(arg1,arg2);
2679     } catch (std::out_of_range& e) {
2680       {
2681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2682       };
2683     } catch (std::exception& e) {
2684       {
2685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2690       };
2691     }
2692   }
2693 }
2694
2695
2696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2697   int jresult ;
2698   intp *arg1 = (intp *) 0 ;
2699   int result;
2700
2701   arg1 = (intp *)jarg1;
2702   {
2703     try {
2704       result = (int)intp_value(arg1);
2705     } catch (std::out_of_range& e) {
2706       {
2707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (std::exception& e) {
2710       {
2711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (...) {
2714       {
2715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2716       };
2717     }
2718   }
2719   jresult = result;
2720   return jresult;
2721 }
2722
2723
2724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2725   void * jresult ;
2726   intp *arg1 = (intp *) 0 ;
2727   int *result = 0 ;
2728
2729   arg1 = (intp *)jarg1;
2730   {
2731     try {
2732       result = (int *)intp_cast(arg1);
2733     } catch (std::out_of_range& e) {
2734       {
2735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2736       };
2737     } catch (std::exception& e) {
2738       {
2739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2740       };
2741     } catch (...) {
2742       {
2743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2744       };
2745     }
2746   }
2747   jresult = (void *)result;
2748   return jresult;
2749 }
2750
2751
2752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2753   void * jresult ;
2754   int *arg1 = (int *) 0 ;
2755   intp *result = 0 ;
2756
2757   arg1 = (int *)jarg1;
2758   {
2759     try {
2760       result = (intp *)intp_frompointer(arg1);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2768       };
2769     } catch (...) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2772       };
2773     }
2774   }
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2781   void * jresult ;
2782   doublep *result = 0 ;
2783
2784   {
2785     try {
2786       result = (doublep *)new_doublep();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (...) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2798       };
2799     }
2800   }
2801   jresult = (void *)result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2807   doublep *arg1 = (doublep *) 0 ;
2808
2809   arg1 = (doublep *)jarg1;
2810   {
2811     try {
2812       delete_doublep(arg1);
2813     } catch (std::out_of_range& e) {
2814       {
2815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2816       };
2817     } catch (std::exception& e) {
2818       {
2819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2820       };
2821     } catch (...) {
2822       {
2823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2824       };
2825     }
2826   }
2827 }
2828
2829
2830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2831   doublep *arg1 = (doublep *) 0 ;
2832   double arg2 ;
2833
2834   arg1 = (doublep *)jarg1;
2835   arg2 = (double)jarg2;
2836   {
2837     try {
2838       doublep_assign(arg1,arg2);
2839     } catch (std::out_of_range& e) {
2840       {
2841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2842       };
2843     } catch (std::exception& e) {
2844       {
2845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2846       };
2847     } catch (...) {
2848       {
2849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2850       };
2851     }
2852   }
2853 }
2854
2855
2856 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2857   double jresult ;
2858   doublep *arg1 = (doublep *) 0 ;
2859   double result;
2860
2861   arg1 = (doublep *)jarg1;
2862   {
2863     try {
2864       result = (double)doublep_value(arg1);
2865     } catch (std::out_of_range& e) {
2866       {
2867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2868       };
2869     } catch (std::exception& e) {
2870       {
2871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2872       };
2873     } catch (...) {
2874       {
2875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2876       };
2877     }
2878   }
2879   jresult = result;
2880   return jresult;
2881 }
2882
2883
2884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2885   void * jresult ;
2886   doublep *arg1 = (doublep *) 0 ;
2887   double *result = 0 ;
2888
2889   arg1 = (doublep *)jarg1;
2890   {
2891     try {
2892       result = (double *)doublep_cast(arg1);
2893     } catch (std::out_of_range& e) {
2894       {
2895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2896       };
2897     } catch (std::exception& e) {
2898       {
2899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2900       };
2901     } catch (...) {
2902       {
2903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2904       };
2905     }
2906   }
2907   jresult = (void *)result;
2908   return jresult;
2909 }
2910
2911
2912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2913   void * jresult ;
2914   double *arg1 = (double *) 0 ;
2915   doublep *result = 0 ;
2916
2917   arg1 = (double *)jarg1;
2918   {
2919     try {
2920       result = (doublep *)doublep_frompointer(arg1);
2921     } catch (std::out_of_range& e) {
2922       {
2923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2924       };
2925     } catch (std::exception& e) {
2926       {
2927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2928       };
2929     } catch (...) {
2930       {
2931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2932       };
2933     }
2934   }
2935   jresult = (void *)result;
2936   return jresult;
2937 }
2938
2939
2940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2941   void * jresult ;
2942   uintp *result = 0 ;
2943
2944   {
2945     try {
2946       result = (uintp *)new_uintp();
2947     } catch (std::out_of_range& e) {
2948       {
2949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (std::exception& e) {
2952       {
2953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961   jresult = (void *)result;
2962   return jresult;
2963 }
2964
2965
2966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2967   uintp *arg1 = (uintp *) 0 ;
2968
2969   arg1 = (uintp *)jarg1;
2970   {
2971     try {
2972       delete_uintp(arg1);
2973     } catch (std::out_of_range& e) {
2974       {
2975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2976       };
2977     } catch (std::exception& e) {
2978       {
2979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2980       };
2981     } catch (...) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2984       };
2985     }
2986   }
2987 }
2988
2989
2990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2991   uintp *arg1 = (uintp *) 0 ;
2992   unsigned int arg2 ;
2993
2994   arg1 = (uintp *)jarg1;
2995   arg2 = (unsigned int)jarg2;
2996   {
2997     try {
2998       uintp_assign(arg1,arg2);
2999     } catch (std::out_of_range& e) {
3000       {
3001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3002       };
3003     } catch (std::exception& e) {
3004       {
3005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3006       };
3007     } catch (...) {
3008       {
3009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3010       };
3011     }
3012   }
3013 }
3014
3015
3016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3017   unsigned int jresult ;
3018   uintp *arg1 = (uintp *) 0 ;
3019   unsigned int result;
3020
3021   arg1 = (uintp *)jarg1;
3022   {
3023     try {
3024       result = (unsigned int)uintp_value(arg1);
3025     } catch (std::out_of_range& e) {
3026       {
3027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (std::exception& e) {
3030       {
3031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3032       };
3033     } catch (...) {
3034       {
3035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3036       };
3037     }
3038   }
3039   jresult = result;
3040   return jresult;
3041 }
3042
3043
3044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3045   void * jresult ;
3046   uintp *arg1 = (uintp *) 0 ;
3047   unsigned int *result = 0 ;
3048
3049   arg1 = (uintp *)jarg1;
3050   {
3051     try {
3052       result = (unsigned int *)uintp_cast(arg1);
3053     } catch (std::out_of_range& e) {
3054       {
3055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3056       };
3057     } catch (std::exception& e) {
3058       {
3059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3060       };
3061     } catch (...) {
3062       {
3063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3064       };
3065     }
3066   }
3067   jresult = (void *)result;
3068   return jresult;
3069 }
3070
3071
3072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3073   void * jresult ;
3074   unsigned int *arg1 = (unsigned int *) 0 ;
3075   uintp *result = 0 ;
3076
3077   arg1 = (unsigned int *)jarg1;
3078   {
3079     try {
3080       result = (uintp *)uintp_frompointer(arg1);
3081     } catch (std::out_of_range& e) {
3082       {
3083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3084       };
3085     } catch (std::exception& e) {
3086       {
3087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3088       };
3089     } catch (...) {
3090       {
3091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3092       };
3093     }
3094   }
3095   jresult = (void *)result;
3096   return jresult;
3097 }
3098
3099
3100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3101   void * jresult ;
3102   ushortp *result = 0 ;
3103
3104   {
3105     try {
3106       result = (ushortp *)new_ushortp();
3107     } catch (std::out_of_range& e) {
3108       {
3109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (std::exception& e) {
3112       {
3113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121   jresult = (void *)result;
3122   return jresult;
3123 }
3124
3125
3126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3127   ushortp *arg1 = (ushortp *) 0 ;
3128
3129   arg1 = (ushortp *)jarg1;
3130   {
3131     try {
3132       delete_ushortp(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3140       };
3141     } catch (...) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3144       };
3145     }
3146   }
3147 }
3148
3149
3150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3151   ushortp *arg1 = (ushortp *) 0 ;
3152   unsigned short arg2 ;
3153
3154   arg1 = (ushortp *)jarg1;
3155   arg2 = (unsigned short)jarg2;
3156   {
3157     try {
3158       ushortp_assign(arg1,arg2);
3159     } catch (std::out_of_range& e) {
3160       {
3161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3162       };
3163     } catch (std::exception& e) {
3164       {
3165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3166       };
3167     } catch (...) {
3168       {
3169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3170       };
3171     }
3172   }
3173 }
3174
3175
3176 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3177   unsigned short jresult ;
3178   ushortp *arg1 = (ushortp *) 0 ;
3179   unsigned short result;
3180
3181   arg1 = (ushortp *)jarg1;
3182   {
3183     try {
3184       result = (unsigned short)ushortp_value(arg1);
3185     } catch (std::out_of_range& e) {
3186       {
3187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3188       };
3189     } catch (std::exception& e) {
3190       {
3191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3192       };
3193     } catch (...) {
3194       {
3195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3196       };
3197     }
3198   }
3199   jresult = result;
3200   return jresult;
3201 }
3202
3203
3204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3205   void * jresult ;
3206   ushortp *arg1 = (ushortp *) 0 ;
3207   unsigned short *result = 0 ;
3208
3209   arg1 = (ushortp *)jarg1;
3210   {
3211     try {
3212       result = (unsigned short *)ushortp_cast(arg1);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (...) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3224       };
3225     }
3226   }
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3233   void * jresult ;
3234   unsigned short *arg1 = (unsigned short *) 0 ;
3235   ushortp *result = 0 ;
3236
3237   arg1 = (unsigned short *)jarg1;
3238   {
3239     try {
3240       result = (ushortp *)ushortp_frompointer(arg1);
3241     } catch (std::out_of_range& e) {
3242       {
3243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3244       };
3245     } catch (std::exception& e) {
3246       {
3247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3248       };
3249     } catch (...) {
3250       {
3251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3252       };
3253     }
3254   }
3255   jresult = (void *)result;
3256   return jresult;
3257 }
3258
3259
3260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3261   unsigned int jresult ;
3262   int arg1 ;
3263   unsigned int result;
3264
3265   arg1 = (int)jarg1;
3266   {
3267     try {
3268       result = (unsigned int)int_to_uint(arg1);
3269     } catch (std::out_of_range& e) {
3270       {
3271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (std::exception& e) {
3274       {
3275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3276       };
3277     } catch (...) {
3278       {
3279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3280       };
3281     }
3282   }
3283   jresult = result;
3284   return jresult;
3285 }
3286
3287
3288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3289   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3290
3291   arg1 = (Dali::RefObject *)jarg1;
3292   {
3293     try {
3294       (arg1)->Reference();
3295     } catch (std::out_of_range& e) {
3296       {
3297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3298       };
3299     } catch (std::exception& e) {
3300       {
3301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3306       };
3307     }
3308   }
3309 }
3310
3311
3312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3313   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3314
3315   arg1 = (Dali::RefObject *)jarg1;
3316   {
3317     try {
3318       (arg1)->Unreference();
3319     } catch (std::out_of_range& e) {
3320       {
3321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3322       };
3323     } catch (std::exception& e) {
3324       {
3325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3326       };
3327     } catch (...) {
3328       {
3329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3330       };
3331     }
3332   }
3333 }
3334
3335
3336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3337   int jresult ;
3338   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3339   int result;
3340
3341   arg1 = (Dali::RefObject *)jarg1;
3342   {
3343     try {
3344       result = (int)(arg1)->ReferenceCount();
3345     } catch (std::out_of_range& e) {
3346       {
3347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3348       };
3349     } catch (std::exception& e) {
3350       {
3351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3356       };
3357     }
3358   }
3359   jresult = result;
3360   return jresult;
3361 }
3362
3363
3364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3365   void * jresult ;
3366   Dali::Any *result = 0 ;
3367
3368   {
3369     try {
3370       result = (Dali::Any *)new Dali::Any();
3371     } catch (std::out_of_range& e) {
3372       {
3373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3374       };
3375     } catch (std::exception& e) {
3376       {
3377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3378       };
3379     } catch (...) {
3380       {
3381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3382       };
3383     }
3384   }
3385   jresult = (void *)result;
3386   return jresult;
3387 }
3388
3389
3390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3391   Dali::Any *arg1 = (Dali::Any *) 0 ;
3392
3393   arg1 = (Dali::Any *)jarg1;
3394   {
3395     try {
3396       delete arg1;
3397     } catch (std::out_of_range& e) {
3398       {
3399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3400       };
3401     } catch (std::exception& e) {
3402       {
3403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3404       };
3405     } catch (...) {
3406       {
3407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3408       };
3409     }
3410   }
3411 }
3412
3413
3414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3415   char *arg1 = (char *) 0 ;
3416
3417   arg1 = (char *)jarg1;
3418   {
3419     try {
3420       Dali::Any::AssertAlways((char const *)arg1);
3421     } catch (std::out_of_range& e) {
3422       {
3423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (std::exception& e) {
3426       {
3427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435 }
3436
3437
3438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3439   void * jresult ;
3440   Dali::Any *arg1 = 0 ;
3441   Dali::Any *result = 0 ;
3442
3443   arg1 = (Dali::Any *)jarg1;
3444   if (!arg1) {
3445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3446     return 0;
3447   }
3448   {
3449     try {
3450       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3451     } catch (std::out_of_range& e) {
3452       {
3453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (std::exception& e) {
3456       {
3457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465   jresult = (void *)result;
3466   return jresult;
3467 }
3468
3469
3470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3471   void * jresult ;
3472   Dali::Any *arg1 = (Dali::Any *) 0 ;
3473   Dali::Any *arg2 = 0 ;
3474   Dali::Any *result = 0 ;
3475
3476   arg1 = (Dali::Any *)jarg1;
3477   arg2 = (Dali::Any *)jarg2;
3478   if (!arg2) {
3479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3480     return 0;
3481   }
3482   {
3483     try {
3484       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3485     } catch (std::out_of_range& e) {
3486       {
3487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (std::exception& e) {
3490       {
3491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3505   void * jresult ;
3506   Dali::Any *arg1 = (Dali::Any *) 0 ;
3507   std::type_info *result = 0 ;
3508
3509   arg1 = (Dali::Any *)jarg1;
3510   {
3511     try {
3512       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (...) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3524       };
3525     }
3526   }
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3533   unsigned int jresult ;
3534   Dali::Any *arg1 = (Dali::Any *) 0 ;
3535   bool result;
3536
3537   arg1 = (Dali::Any *)jarg1;
3538   {
3539     try {
3540       result = (bool)((Dali::Any const *)arg1)->Empty();
3541     } catch (std::out_of_range& e) {
3542       {
3543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3544       };
3545     } catch (std::exception& e) {
3546       {
3547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (...) {
3550       {
3551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3552       };
3553     }
3554   }
3555   jresult = result;
3556   return jresult;
3557 }
3558
3559
3560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3561   void * jresult ;
3562   std::type_info *arg1 = 0 ;
3563   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3564   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3565   Dali::Any::AnyContainerBase *result = 0 ;
3566
3567   arg1 = (std::type_info *)jarg1;
3568   if (!arg1) {
3569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3570     return 0;
3571   }
3572   arg2 = (Dali::Any::CloneFunc)jarg2;
3573   arg3 = (Dali::Any::DeleteFunc)jarg3;
3574   {
3575     try {
3576       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3584       };
3585     } catch (...) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3588       };
3589     }
3590   }
3591   jresult = (void *)result;
3592   return jresult;
3593 }
3594
3595
3596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3597   void * jresult ;
3598   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3599   std::type_info *result = 0 ;
3600
3601   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3602   {
3603     try {
3604       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3605     } catch (std::out_of_range& e) {
3606       {
3607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3608       };
3609     } catch (std::exception& e) {
3610       {
3611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3612       };
3613     } catch (...) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3616       };
3617     }
3618   }
3619   jresult = (void *)result;
3620   return jresult;
3621 }
3622
3623
3624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3625   void * jresult ;
3626   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3627   ::std::type_info *result = 0 ;
3628
3629   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3630   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3631   jresult = (void *)result;
3632   return jresult;
3633 }
3634
3635
3636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3637   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3638   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3639
3640   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3641   arg2 = (Dali::Any::CloneFunc)jarg2;
3642   if (arg1) (arg1)->mCloneFunc = arg2;
3643 }
3644
3645
3646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3647   void * jresult ;
3648   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3649   Dali::Any::CloneFunc result;
3650
3651   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3652   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3653   jresult = (void *)result;
3654   return jresult;
3655 }
3656
3657
3658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3659   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3660   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3661
3662   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3663   arg2 = (Dali::Any::DeleteFunc)jarg2;
3664   if (arg1) (arg1)->mDeleteFunc = arg2;
3665 }
3666
3667
3668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3669   void * jresult ;
3670   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3671   Dali::Any::DeleteFunc result;
3672
3673   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3674   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3675   jresult = (void *)result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3681   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3682
3683   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3684   {
3685     try {
3686       delete arg1;
3687     } catch (std::out_of_range& e) {
3688       {
3689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3690       };
3691     } catch (std::exception& e) {
3692       {
3693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3694       };
3695     } catch (...) {
3696       {
3697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3698       };
3699     }
3700   }
3701 }
3702
3703
3704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3705   Dali::Any *arg1 = (Dali::Any *) 0 ;
3706   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3707
3708   arg1 = (Dali::Any *)jarg1;
3709   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3710   if (arg1) (arg1)->mContainer = arg2;
3711 }
3712
3713
3714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3715   void * jresult ;
3716   Dali::Any *arg1 = (Dali::Any *) 0 ;
3717   Dali::Any::AnyContainerBase *result = 0 ;
3718
3719   arg1 = (Dali::Any *)jarg1;
3720   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3721   jresult = (void *)result;
3722   return jresult;
3723 }
3724
3725
3726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3727   char *arg1 = (char *) 0 ;
3728   char *arg2 = (char *) 0 ;
3729
3730   arg1 = (char *)jarg1;
3731   arg2 = (char *)jarg2;
3732   {
3733     try {
3734       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3735     } catch (std::out_of_range& e) {
3736       {
3737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (std::exception& e) {
3740       {
3741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749 }
3750
3751
3752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3753   void * jresult ;
3754   char *arg1 = (char *) 0 ;
3755   char *arg2 = (char *) 0 ;
3756   Dali::DaliException *result = 0 ;
3757
3758   arg1 = (char *)jarg1;
3759   arg2 = (char *)jarg2;
3760   {
3761     try {
3762       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (...) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3774       };
3775     }
3776   }
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3783   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3784   char *arg2 = (char *) 0 ;
3785
3786   arg1 = (Dali::DaliException *)jarg1;
3787   arg2 = (char *)jarg2;
3788   {
3789     if (arg2) {
3790       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3791       strcpy((char *)arg1->location, (const char *)arg2);
3792     } else {
3793       arg1->location = 0;
3794     }
3795   }
3796 }
3797
3798
3799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3800   char * jresult ;
3801   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3802   char *result = 0 ;
3803
3804   arg1 = (Dali::DaliException *)jarg1;
3805   result = (char *) ((arg1)->location);
3806   jresult = SWIG_csharp_string_callback((const char *)result);
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3812   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3813   char *arg2 = (char *) 0 ;
3814
3815   arg1 = (Dali::DaliException *)jarg1;
3816   arg2 = (char *)jarg2;
3817   {
3818     if (arg2) {
3819       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3820       strcpy((char *)arg1->condition, (const char *)arg2);
3821     } else {
3822       arg1->condition = 0;
3823     }
3824   }
3825 }
3826
3827
3828 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3829   char * jresult ;
3830   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3831   char *result = 0 ;
3832
3833   arg1 = (Dali::DaliException *)jarg1;
3834   result = (char *) ((arg1)->condition);
3835   jresult = SWIG_csharp_string_callback((const char *)result);
3836   return jresult;
3837 }
3838
3839
3840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3841   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3842
3843   arg1 = (Dali::DaliException *)jarg1;
3844   {
3845     try {
3846       delete arg1;
3847     } catch (std::out_of_range& e) {
3848       {
3849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3850       };
3851     } catch (std::exception& e) {
3852       {
3853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3854       };
3855     } catch (...) {
3856       {
3857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3858       };
3859     }
3860   }
3861 }
3862
3863
3864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3865   void * jresult ;
3866   Dali::Vector2 *result = 0 ;
3867
3868   {
3869     try {
3870       result = (Dali::Vector2 *)new Dali::Vector2();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (...) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3882       };
3883     }
3884   }
3885   jresult = (void *)result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3891   void * jresult ;
3892   float arg1 ;
3893   float arg2 ;
3894   Dali::Vector2 *result = 0 ;
3895
3896   arg1 = (float)jarg1;
3897   arg2 = (float)jarg2;
3898   {
3899     try {
3900       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3901     } catch (std::out_of_range& e) {
3902       {
3903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3904       };
3905     } catch (std::exception& e) {
3906       {
3907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3908       };
3909     } catch (...) {
3910       {
3911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3912       };
3913     }
3914   }
3915   jresult = (void *)result;
3916   return jresult;
3917 }
3918
3919
3920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3921   void * jresult ;
3922   float *arg1 = (float *) 0 ;
3923   Dali::Vector2 *result = 0 ;
3924
3925   arg1 = jarg1;
3926   {
3927     try {
3928       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3929     } catch (std::out_of_range& e) {
3930       {
3931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3932       };
3933     } catch (std::exception& e) {
3934       {
3935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3936       };
3937     } catch (...) {
3938       {
3939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3940       };
3941     }
3942   }
3943   jresult = (void *)result;
3944
3945
3946   return jresult;
3947 }
3948
3949
3950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3951   void * jresult ;
3952   Dali::Vector3 *arg1 = 0 ;
3953   Dali::Vector2 *result = 0 ;
3954
3955   arg1 = (Dali::Vector3 *)jarg1;
3956   if (!arg1) {
3957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3958     return 0;
3959   }
3960   {
3961     try {
3962       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3963     } catch (std::out_of_range& e) {
3964       {
3965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3966       };
3967     } catch (std::exception& e) {
3968       {
3969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3970       };
3971     } catch (...) {
3972       {
3973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3974       };
3975     }
3976   }
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3983   void * jresult ;
3984   Dali::Vector4 *arg1 = 0 ;
3985   Dali::Vector2 *result = 0 ;
3986
3987   arg1 = (Dali::Vector4 *)jarg1;
3988   if (!arg1) {
3989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3990     return 0;
3991   }
3992   {
3993     try {
3994       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3995     } catch (std::out_of_range& e) {
3996       {
3997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3998       };
3999     } catch (std::exception& e) {
4000       {
4001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4002       };
4003     } catch (...) {
4004       {
4005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4006       };
4007     }
4008   }
4009   jresult = (void *)result;
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4015   void * jresult ;
4016   Dali::Vector2 *result = 0 ;
4017
4018   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4019   jresult = (void *)result;
4020   return jresult;
4021 }
4022
4023
4024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4025   void * jresult ;
4026   Dali::Vector2 *result = 0 ;
4027
4028   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4029   jresult = (void *)result;
4030   return jresult;
4031 }
4032
4033
4034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4035   void * jresult ;
4036   Dali::Vector2 *result = 0 ;
4037
4038   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4039   jresult = (void *)result;
4040   return jresult;
4041 }
4042
4043
4044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4045   void * jresult ;
4046   Dali::Vector2 *result = 0 ;
4047
4048   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4049   jresult = (void *)result;
4050   return jresult;
4051 }
4052
4053
4054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4055   void * jresult ;
4056   Dali::Vector2 *result = 0 ;
4057
4058   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4059   jresult = (void *)result;
4060   return jresult;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4065   void * jresult ;
4066   Dali::Vector2 *result = 0 ;
4067
4068   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4075   void * jresult ;
4076   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4077   float *arg2 = (float *) 0 ;
4078   Dali::Vector2 *result = 0 ;
4079
4080   arg1 = (Dali::Vector2 *)jarg1;
4081   arg2 = jarg2;
4082   {
4083     try {
4084       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4092       };
4093     } catch (...) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4096       };
4097     }
4098   }
4099   jresult = (void *)result;
4100
4101
4102   return jresult;
4103 }
4104
4105
4106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4107   void * jresult ;
4108   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4109   Dali::Vector3 *arg2 = 0 ;
4110   Dali::Vector2 *result = 0 ;
4111
4112   arg1 = (Dali::Vector2 *)jarg1;
4113   arg2 = (Dali::Vector3 *)jarg2;
4114   if (!arg2) {
4115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4116     return 0;
4117   }
4118   {
4119     try {
4120       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4121     } catch (std::out_of_range& e) {
4122       {
4123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4124       };
4125     } catch (std::exception& e) {
4126       {
4127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4128       };
4129     } catch (...) {
4130       {
4131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4132       };
4133     }
4134   }
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4141   void * jresult ;
4142   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4143   Dali::Vector4 *arg2 = 0 ;
4144   Dali::Vector2 *result = 0 ;
4145
4146   arg1 = (Dali::Vector2 *)jarg1;
4147   arg2 = (Dali::Vector4 *)jarg2;
4148   if (!arg2) {
4149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4150     return 0;
4151   }
4152   {
4153     try {
4154       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4155     } catch (std::out_of_range& e) {
4156       {
4157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4158       };
4159     } catch (std::exception& e) {
4160       {
4161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4162       };
4163     } catch (...) {
4164       {
4165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4166       };
4167     }
4168   }
4169   jresult = (void *)result;
4170   return jresult;
4171 }
4172
4173
4174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4175   void * jresult ;
4176   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4177   Dali::Vector2 *arg2 = 0 ;
4178   Dali::Vector2 result;
4179
4180   arg1 = (Dali::Vector2 *)jarg1;
4181   arg2 = (Dali::Vector2 *)jarg2;
4182   if (!arg2) {
4183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4184     return 0;
4185   }
4186   {
4187     try {
4188       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4189     } catch (std::out_of_range& e) {
4190       {
4191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4192       };
4193     } catch (std::exception& e) {
4194       {
4195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4196       };
4197     } catch (...) {
4198       {
4199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4200       };
4201     }
4202   }
4203   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4204   return jresult;
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4209   void * jresult ;
4210   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4211   Dali::Vector2 *arg2 = 0 ;
4212   Dali::Vector2 *result = 0 ;
4213
4214   arg1 = (Dali::Vector2 *)jarg1;
4215   arg2 = (Dali::Vector2 *)jarg2;
4216   if (!arg2) {
4217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4218     return 0;
4219   }
4220   {
4221     try {
4222       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4223     } catch (std::out_of_range& e) {
4224       {
4225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (std::exception& e) {
4228       {
4229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4230       };
4231     } catch (...) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4234       };
4235     }
4236   }
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4243   void * jresult ;
4244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4245   Dali::Vector2 *arg2 = 0 ;
4246   Dali::Vector2 result;
4247
4248   arg1 = (Dali::Vector2 *)jarg1;
4249   arg2 = (Dali::Vector2 *)jarg2;
4250   if (!arg2) {
4251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4252     return 0;
4253   }
4254   {
4255     try {
4256       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4257     } catch (std::out_of_range& e) {
4258       {
4259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4260       };
4261     } catch (std::exception& e) {
4262       {
4263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4264       };
4265     } catch (...) {
4266       {
4267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4268       };
4269     }
4270   }
4271   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4272   return jresult;
4273 }
4274
4275
4276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4277   void * jresult ;
4278   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4279   Dali::Vector2 *arg2 = 0 ;
4280   Dali::Vector2 *result = 0 ;
4281
4282   arg1 = (Dali::Vector2 *)jarg1;
4283   arg2 = (Dali::Vector2 *)jarg2;
4284   if (!arg2) {
4285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4286     return 0;
4287   }
4288   {
4289     try {
4290       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (...) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4302       };
4303     }
4304   }
4305   jresult = (void *)result;
4306   return jresult;
4307 }
4308
4309
4310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4311   void * jresult ;
4312   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4313   Dali::Vector2 *arg2 = 0 ;
4314   Dali::Vector2 result;
4315
4316   arg1 = (Dali::Vector2 *)jarg1;
4317   arg2 = (Dali::Vector2 *)jarg2;
4318   if (!arg2) {
4319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4320     return 0;
4321   }
4322   {
4323     try {
4324       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (...) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4336       };
4337     }
4338   }
4339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4340   return jresult;
4341 }
4342
4343
4344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4345   void * jresult ;
4346   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4347   float arg2 ;
4348   Dali::Vector2 result;
4349
4350   arg1 = (Dali::Vector2 *)jarg1;
4351   arg2 = (float)jarg2;
4352   {
4353     try {
4354       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4355     } catch (std::out_of_range& e) {
4356       {
4357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4358       };
4359     } catch (std::exception& e) {
4360       {
4361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (...) {
4364       {
4365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4366       };
4367     }
4368   }
4369   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4370   return jresult;
4371 }
4372
4373
4374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4375   void * jresult ;
4376   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4377   Dali::Vector2 *arg2 = 0 ;
4378   Dali::Vector2 *result = 0 ;
4379
4380   arg1 = (Dali::Vector2 *)jarg1;
4381   arg2 = (Dali::Vector2 *)jarg2;
4382   if (!arg2) {
4383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4384     return 0;
4385   }
4386   {
4387     try {
4388       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4389     } catch (std::out_of_range& e) {
4390       {
4391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4392       };
4393     } catch (std::exception& e) {
4394       {
4395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4396       };
4397     } catch (...) {
4398       {
4399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4400       };
4401     }
4402   }
4403   jresult = (void *)result;
4404   return jresult;
4405 }
4406
4407
4408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4409   void * jresult ;
4410   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4411   float arg2 ;
4412   Dali::Vector2 *result = 0 ;
4413
4414   arg1 = (Dali::Vector2 *)jarg1;
4415   arg2 = (float)jarg2;
4416   {
4417     try {
4418       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4419     } catch (std::out_of_range& e) {
4420       {
4421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4422       };
4423     } catch (std::exception& e) {
4424       {
4425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (...) {
4428       {
4429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4430       };
4431     }
4432   }
4433   jresult = (void *)result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4439   void * jresult ;
4440   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4441   Dali::Vector2 *arg2 = 0 ;
4442   Dali::Vector2 result;
4443
4444   arg1 = (Dali::Vector2 *)jarg1;
4445   arg2 = (Dali::Vector2 *)jarg2;
4446   if (!arg2) {
4447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4448     return 0;
4449   }
4450   {
4451     try {
4452       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4453     } catch (std::out_of_range& e) {
4454       {
4455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4456       };
4457     } catch (std::exception& e) {
4458       {
4459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (...) {
4462       {
4463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4464       };
4465     }
4466   }
4467   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4468   return jresult;
4469 }
4470
4471
4472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4473   void * jresult ;
4474   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4475   float arg2 ;
4476   Dali::Vector2 result;
4477
4478   arg1 = (Dali::Vector2 *)jarg1;
4479   arg2 = (float)jarg2;
4480   {
4481     try {
4482       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4483     } catch (std::out_of_range& e) {
4484       {
4485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4486       };
4487     } catch (std::exception& e) {
4488       {
4489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (...) {
4492       {
4493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4494       };
4495     }
4496   }
4497   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4503   void * jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector2 *arg2 = 0 ;
4506   Dali::Vector2 *result = 0 ;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector2 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (...) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4528       };
4529     }
4530   }
4531   jresult = (void *)result;
4532   return jresult;
4533 }
4534
4535
4536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4537   void * jresult ;
4538   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4539   float arg2 ;
4540   Dali::Vector2 *result = 0 ;
4541
4542   arg1 = (Dali::Vector2 *)jarg1;
4543   arg2 = (float)jarg2;
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (...) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4558       };
4559     }
4560   }
4561   jresult = (void *)result;
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 result;
4570
4571   arg1 = (Dali::Vector2 *)jarg1;
4572   {
4573     try {
4574       result = ((Dali::Vector2 const *)arg1)->operator -();
4575     } catch (std::out_of_range& e) {
4576       {
4577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4578       };
4579     } catch (std::exception& e) {
4580       {
4581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4582       };
4583     } catch (...) {
4584       {
4585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4586       };
4587     }
4588   }
4589   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4590   return jresult;
4591 }
4592
4593
4594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4595   unsigned int jresult ;
4596   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4597   Dali::Vector2 *arg2 = 0 ;
4598   bool result;
4599
4600   arg1 = (Dali::Vector2 *)jarg1;
4601   arg2 = (Dali::Vector2 *)jarg2;
4602   if (!arg2) {
4603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4604     return 0;
4605   }
4606   {
4607     try {
4608       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4609     } catch (std::out_of_range& e) {
4610       {
4611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4612       };
4613     } catch (std::exception& e) {
4614       {
4615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (...) {
4618       {
4619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4620       };
4621     }
4622   }
4623   jresult = result;
4624   return jresult;
4625 }
4626
4627
4628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4629   unsigned int jresult ;
4630   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4631   Dali::Vector2 *arg2 = 0 ;
4632   bool result;
4633
4634   arg1 = (Dali::Vector2 *)jarg1;
4635   arg2 = (Dali::Vector2 *)jarg2;
4636   if (!arg2) {
4637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4638     return 0;
4639   }
4640   {
4641     try {
4642       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4643     } catch (std::out_of_range& e) {
4644       {
4645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4646       };
4647     } catch (std::exception& e) {
4648       {
4649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4650       };
4651     } catch (...) {
4652       {
4653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4654       };
4655     }
4656   }
4657   jresult = result;
4658   return jresult;
4659 }
4660
4661
4662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4663   float jresult ;
4664   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4665   unsigned int arg2 ;
4666   float *result = 0 ;
4667
4668   arg1 = (Dali::Vector2 *)jarg1;
4669   arg2 = (unsigned int)jarg2;
4670   {
4671     try {
4672       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4673     } catch (std::out_of_range& e) {
4674       {
4675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (std::exception& e) {
4678       {
4679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4680       };
4681     } catch (...) {
4682       {
4683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4684       };
4685     }
4686   }
4687   jresult = *result;
4688   return jresult;
4689 }
4690
4691
4692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4693   float jresult ;
4694   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4695   float result;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   {
4699     try {
4700       result = (float)((Dali::Vector2 const *)arg1)->Length();
4701     } catch (std::out_of_range& e) {
4702       {
4703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4704       };
4705     } catch (std::exception& e) {
4706       {
4707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4708       };
4709     } catch (...) {
4710       {
4711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4712       };
4713     }
4714   }
4715   jresult = result;
4716   return jresult;
4717 }
4718
4719
4720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4721   float jresult ;
4722   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4723   float result;
4724
4725   arg1 = (Dali::Vector2 *)jarg1;
4726   {
4727     try {
4728       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4729     } catch (std::out_of_range& e) {
4730       {
4731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (std::exception& e) {
4734       {
4735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (...) {
4738       {
4739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4740       };
4741     }
4742   }
4743   jresult = result;
4744   return jresult;
4745 }
4746
4747
4748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4749   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4750
4751   arg1 = (Dali::Vector2 *)jarg1;
4752   {
4753     try {
4754       (arg1)->Normalize();
4755     } catch (std::out_of_range& e) {
4756       {
4757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4758       };
4759     } catch (std::exception& e) {
4760       {
4761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4762       };
4763     } catch (...) {
4764       {
4765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4766       };
4767     }
4768   }
4769 }
4770
4771
4772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4773   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4774   Dali::Vector2 *arg2 = 0 ;
4775   Dali::Vector2 *arg3 = 0 ;
4776
4777   arg1 = (Dali::Vector2 *)jarg1;
4778   arg2 = (Dali::Vector2 *)jarg2;
4779   if (!arg2) {
4780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4781     return ;
4782   }
4783   arg3 = (Dali::Vector2 *)jarg3;
4784   if (!arg3) {
4785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4786     return ;
4787   }
4788   {
4789     try {
4790       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4791     } catch (std::out_of_range& e) {
4792       {
4793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4794       };
4795     } catch (std::exception& e) {
4796       {
4797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4798       };
4799     } catch (...) {
4800       {
4801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4802       };
4803     }
4804   }
4805 }
4806
4807
4808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4809   void * jresult ;
4810   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4811   float *result = 0 ;
4812
4813   arg1 = (Dali::Vector2 *)jarg1;
4814   {
4815     try {
4816       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (...) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4828       };
4829     }
4830   }
4831   jresult = (void *)result;
4832   return jresult;
4833 }
4834
4835
4836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float arg2 ;
4839
4840   arg1 = (Dali::Vector2 *)jarg1;
4841   arg2 = (float)jarg2;
4842   if (arg1) (arg1)->x = arg2;
4843 }
4844
4845
4846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4847   float jresult ;
4848   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4849   float result;
4850
4851   arg1 = (Dali::Vector2 *)jarg1;
4852   result = (float) ((arg1)->x);
4853   jresult = result;
4854   return jresult;
4855 }
4856
4857
4858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4859   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4860   float arg2 ;
4861
4862   arg1 = (Dali::Vector2 *)jarg1;
4863   arg2 = (float)jarg2;
4864   if (arg1) (arg1)->width = arg2;
4865 }
4866
4867
4868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4869   float jresult ;
4870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4871   float result;
4872
4873   arg1 = (Dali::Vector2 *)jarg1;
4874   result = (float) ((arg1)->width);
4875   jresult = result;
4876   return jresult;
4877 }
4878
4879
4880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4881   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4882   float arg2 ;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (float)jarg2;
4886   if (arg1) (arg1)->y = arg2;
4887 }
4888
4889
4890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4891   float jresult ;
4892   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4893   float result;
4894
4895   arg1 = (Dali::Vector2 *)jarg1;
4896   result = (float) ((arg1)->y);
4897   jresult = result;
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   float arg2 ;
4905
4906   arg1 = (Dali::Vector2 *)jarg1;
4907   arg2 = (float)jarg2;
4908   if (arg1) (arg1)->height = arg2;
4909 }
4910
4911
4912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4913   float jresult ;
4914   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4915   float result;
4916
4917   arg1 = (Dali::Vector2 *)jarg1;
4918   result = (float) ((arg1)->height);
4919   jresult = result;
4920   return jresult;
4921 }
4922
4923
4924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4925   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4926
4927   arg1 = (Dali::Vector2 *)jarg1;
4928   {
4929     try {
4930       delete arg1;
4931     } catch (std::out_of_range& e) {
4932       {
4933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4934       };
4935     } catch (std::exception& e) {
4936       {
4937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4938       };
4939     } catch (...) {
4940       {
4941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4942       };
4943     }
4944   }
4945 }
4946
4947
4948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4949   void * jresult ;
4950   Dali::Vector2 *arg1 = 0 ;
4951   Dali::Vector2 *arg2 = 0 ;
4952   Dali::Vector2 result;
4953
4954   arg1 = (Dali::Vector2 *)jarg1;
4955   if (!arg1) {
4956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4957     return 0;
4958   }
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (...) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4978       };
4979     }
4980   }
4981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4987   void * jresult ;
4988   Dali::Vector2 *arg1 = 0 ;
4989   Dali::Vector2 *arg2 = 0 ;
4990   Dali::Vector2 result;
4991
4992   arg1 = (Dali::Vector2 *)jarg1;
4993   if (!arg1) {
4994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4995     return 0;
4996   }
4997   arg2 = (Dali::Vector2 *)jarg2;
4998   if (!arg2) {
4999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5000     return 0;
5001   }
5002   {
5003     try {
5004       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5005     } catch (std::out_of_range& e) {
5006       {
5007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5008       };
5009     } catch (std::exception& e) {
5010       {
5011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5012       };
5013     } catch (...) {
5014       {
5015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5016       };
5017     }
5018   }
5019   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = 0 ;
5027   float *arg2 = 0 ;
5028   float *arg3 = 0 ;
5029   float temp2 ;
5030   float temp3 ;
5031   Dali::Vector2 result;
5032
5033   arg1 = (Dali::Vector2 *)jarg1;
5034   if (!arg1) {
5035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5036     return 0;
5037   }
5038   temp2 = (float)jarg2;
5039   arg2 = &temp2;
5040   temp3 = (float)jarg3;
5041   arg3 = &temp3;
5042   {
5043     try {
5044       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5045     } catch (std::out_of_range& e) {
5046       {
5047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5048       };
5049     } catch (std::exception& e) {
5050       {
5051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5052       };
5053     } catch (...) {
5054       {
5055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5056       };
5057     }
5058   }
5059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5060   return jresult;
5061 }
5062
5063
5064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5065   void * jresult ;
5066   Dali::Vector3 *result = 0 ;
5067
5068   {
5069     try {
5070       result = (Dali::Vector3 *)new Dali::Vector3();
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (...) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5082       };
5083     }
5084   }
5085   jresult = (void *)result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5091   void * jresult ;
5092   float arg1 ;
5093   float arg2 ;
5094   float arg3 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (float)jarg1;
5098   arg2 = (float)jarg2;
5099   arg3 = (float)jarg3;
5100   {
5101     try {
5102       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5103     } catch (std::out_of_range& e) {
5104       {
5105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5106       };
5107     } catch (std::exception& e) {
5108       {
5109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5110       };
5111     } catch (...) {
5112       {
5113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5114       };
5115     }
5116   }
5117   jresult = (void *)result;
5118   return jresult;
5119 }
5120
5121
5122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5123   void * jresult ;
5124   float *arg1 = (float *) 0 ;
5125   Dali::Vector3 *result = 0 ;
5126
5127   arg1 = jarg1;
5128   {
5129     try {
5130       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5131     } catch (std::out_of_range& e) {
5132       {
5133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5134       };
5135     } catch (std::exception& e) {
5136       {
5137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5138       };
5139     } catch (...) {
5140       {
5141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5142       };
5143     }
5144   }
5145   jresult = (void *)result;
5146
5147
5148   return jresult;
5149 }
5150
5151
5152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5153   void * jresult ;
5154   Dali::Vector2 *arg1 = 0 ;
5155   Dali::Vector3 *result = 0 ;
5156
5157   arg1 = (Dali::Vector2 *)jarg1;
5158   if (!arg1) {
5159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5160     return 0;
5161   }
5162   {
5163     try {
5164       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5165     } catch (std::out_of_range& e) {
5166       {
5167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5168       };
5169     } catch (std::exception& e) {
5170       {
5171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5172       };
5173     } catch (...) {
5174       {
5175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5176       };
5177     }
5178   }
5179   jresult = (void *)result;
5180   return jresult;
5181 }
5182
5183
5184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5185   void * jresult ;
5186   Dali::Vector4 *arg1 = 0 ;
5187   Dali::Vector3 *result = 0 ;
5188
5189   arg1 = (Dali::Vector4 *)jarg1;
5190   if (!arg1) {
5191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5192     return 0;
5193   }
5194   {
5195     try {
5196       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5197     } catch (std::out_of_range& e) {
5198       {
5199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5200       };
5201     } catch (std::exception& e) {
5202       {
5203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5204       };
5205     } catch (...) {
5206       {
5207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5208       };
5209     }
5210   }
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5217   void * jresult ;
5218   Dali::Vector3 *result = 0 ;
5219
5220   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5221   jresult = (void *)result;
5222   return jresult;
5223 }
5224
5225
5226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5227   void * jresult ;
5228   Dali::Vector3 *result = 0 ;
5229
5230   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5231   jresult = (void *)result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5237   void * jresult ;
5238   Dali::Vector3 *result = 0 ;
5239
5240   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5241   jresult = (void *)result;
5242   return jresult;
5243 }
5244
5245
5246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5247   void * jresult ;
5248   Dali::Vector3 *result = 0 ;
5249
5250   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5251   jresult = (void *)result;
5252   return jresult;
5253 }
5254
5255
5256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5257   void * jresult ;
5258   Dali::Vector3 *result = 0 ;
5259
5260   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5261   jresult = (void *)result;
5262   return jresult;
5263 }
5264
5265
5266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5267   void * jresult ;
5268   Dali::Vector3 *result = 0 ;
5269
5270   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5271   jresult = (void *)result;
5272   return jresult;
5273 }
5274
5275
5276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5277   void * jresult ;
5278   Dali::Vector3 *result = 0 ;
5279
5280   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5281   jresult = (void *)result;
5282   return jresult;
5283 }
5284
5285
5286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5287   void * jresult ;
5288   Dali::Vector3 *result = 0 ;
5289
5290   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5291   jresult = (void *)result;
5292   return jresult;
5293 }
5294
5295
5296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5297   void * jresult ;
5298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5299   float *arg2 = (float *) 0 ;
5300   Dali::Vector3 *result = 0 ;
5301
5302   arg1 = (Dali::Vector3 *)jarg1;
5303   arg2 = jarg2;
5304   {
5305     try {
5306       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5307     } catch (std::out_of_range& e) {
5308       {
5309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5310       };
5311     } catch (std::exception& e) {
5312       {
5313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5314       };
5315     } catch (...) {
5316       {
5317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5318       };
5319     }
5320   }
5321   jresult = (void *)result;
5322
5323
5324   return jresult;
5325 }
5326
5327
5328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5329   void * jresult ;
5330   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5331   Dali::Vector2 *arg2 = 0 ;
5332   Dali::Vector3 *result = 0 ;
5333
5334   arg1 = (Dali::Vector3 *)jarg1;
5335   arg2 = (Dali::Vector2 *)jarg2;
5336   if (!arg2) {
5337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5338     return 0;
5339   }
5340   {
5341     try {
5342       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5343     } catch (std::out_of_range& e) {
5344       {
5345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5346       };
5347     } catch (std::exception& e) {
5348       {
5349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5350       };
5351     } catch (...) {
5352       {
5353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5354       };
5355     }
5356   }
5357   jresult = (void *)result;
5358   return jresult;
5359 }
5360
5361
5362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5363   void * jresult ;
5364   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5365   Dali::Vector4 *arg2 = 0 ;
5366   Dali::Vector3 *result = 0 ;
5367
5368   arg1 = (Dali::Vector3 *)jarg1;
5369   arg2 = (Dali::Vector4 *)jarg2;
5370   if (!arg2) {
5371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5372     return 0;
5373   }
5374   {
5375     try {
5376       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5377     } catch (std::out_of_range& e) {
5378       {
5379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5380       };
5381     } catch (std::exception& e) {
5382       {
5383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5384       };
5385     } catch (...) {
5386       {
5387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5388       };
5389     }
5390   }
5391   jresult = (void *)result;
5392   return jresult;
5393 }
5394
5395
5396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5397   void * jresult ;
5398   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5399   Dali::Vector3 *arg2 = 0 ;
5400   Dali::Vector3 result;
5401
5402   arg1 = (Dali::Vector3 *)jarg1;
5403   arg2 = (Dali::Vector3 *)jarg2;
5404   if (!arg2) {
5405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5406     return 0;
5407   }
5408   {
5409     try {
5410       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5411     } catch (std::out_of_range& e) {
5412       {
5413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5414       };
5415     } catch (std::exception& e) {
5416       {
5417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5418       };
5419     } catch (...) {
5420       {
5421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5422       };
5423     }
5424   }
5425   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5426   return jresult;
5427 }
5428
5429
5430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5431   void * jresult ;
5432   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5433   Dali::Vector3 *arg2 = 0 ;
5434   Dali::Vector3 *result = 0 ;
5435
5436   arg1 = (Dali::Vector3 *)jarg1;
5437   arg2 = (Dali::Vector3 *)jarg2;
5438   if (!arg2) {
5439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5440     return 0;
5441   }
5442   {
5443     try {
5444       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5445     } catch (std::out_of_range& e) {
5446       {
5447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5448       };
5449     } catch (std::exception& e) {
5450       {
5451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5452       };
5453     } catch (...) {
5454       {
5455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5456       };
5457     }
5458   }
5459   jresult = (void *)result;
5460   return jresult;
5461 }
5462
5463
5464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5465   void * jresult ;
5466   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5467   Dali::Vector3 *arg2 = 0 ;
5468   Dali::Vector3 result;
5469
5470   arg1 = (Dali::Vector3 *)jarg1;
5471   arg2 = (Dali::Vector3 *)jarg2;
5472   if (!arg2) {
5473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5474     return 0;
5475   }
5476   {
5477     try {
5478       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5479     } catch (std::out_of_range& e) {
5480       {
5481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (std::exception& e) {
5484       {
5485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5501   Dali::Vector3 *arg2 = 0 ;
5502   Dali::Vector3 *result = 0 ;
5503
5504   arg1 = (Dali::Vector3 *)jarg1;
5505   arg2 = (Dali::Vector3 *)jarg2;
5506   if (!arg2) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5508     return 0;
5509   }
5510   {
5511     try {
5512       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5513     } catch (std::out_of_range& e) {
5514       {
5515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5516       };
5517     } catch (std::exception& e) {
5518       {
5519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (...) {
5522       {
5523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5524       };
5525     }
5526   }
5527   jresult = (void *)result;
5528   return jresult;
5529 }
5530
5531
5532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5533   void * jresult ;
5534   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5535   Dali::Vector3 *arg2 = 0 ;
5536   Dali::Vector3 result;
5537
5538   arg1 = (Dali::Vector3 *)jarg1;
5539   arg2 = (Dali::Vector3 *)jarg2;
5540   if (!arg2) {
5541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5542     return 0;
5543   }
5544   {
5545     try {
5546       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5547     } catch (std::out_of_range& e) {
5548       {
5549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5550       };
5551     } catch (std::exception& e) {
5552       {
5553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (...) {
5556       {
5557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5558       };
5559     }
5560   }
5561   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5562   return jresult;
5563 }
5564
5565
5566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5567   void * jresult ;
5568   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5569   float arg2 ;
5570   Dali::Vector3 result;
5571
5572   arg1 = (Dali::Vector3 *)jarg1;
5573   arg2 = (float)jarg2;
5574   {
5575     try {
5576       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5577     } catch (std::out_of_range& e) {
5578       {
5579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5580       };
5581     } catch (std::exception& e) {
5582       {
5583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5584       };
5585     } catch (...) {
5586       {
5587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5588       };
5589     }
5590   }
5591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5592   return jresult;
5593 }
5594
5595
5596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5597   void * jresult ;
5598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5599   Dali::Vector3 *arg2 = 0 ;
5600   Dali::Vector3 *result = 0 ;
5601
5602   arg1 = (Dali::Vector3 *)jarg1;
5603   arg2 = (Dali::Vector3 *)jarg2;
5604   if (!arg2) {
5605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5606     return 0;
5607   }
5608   {
5609     try {
5610       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5611     } catch (std::out_of_range& e) {
5612       {
5613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5614       };
5615     } catch (std::exception& e) {
5616       {
5617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (...) {
5620       {
5621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5622       };
5623     }
5624   }
5625   jresult = (void *)result;
5626   return jresult;
5627 }
5628
5629
5630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5631   void * jresult ;
5632   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5633   float arg2 ;
5634   Dali::Vector3 *result = 0 ;
5635
5636   arg1 = (Dali::Vector3 *)jarg1;
5637   arg2 = (float)jarg2;
5638   {
5639     try {
5640       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5641     } catch (std::out_of_range& e) {
5642       {
5643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5644       };
5645     } catch (std::exception& e) {
5646       {
5647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5648       };
5649     } catch (...) {
5650       {
5651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5652       };
5653     }
5654   }
5655   jresult = (void *)result;
5656   return jresult;
5657 }
5658
5659
5660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5661   void * jresult ;
5662   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5663   Dali::Quaternion *arg2 = 0 ;
5664   Dali::Vector3 *result = 0 ;
5665
5666   arg1 = (Dali::Vector3 *)jarg1;
5667   arg2 = (Dali::Quaternion *)jarg2;
5668   if (!arg2) {
5669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5670     return 0;
5671   }
5672   {
5673     try {
5674       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5675     } catch (std::out_of_range& e) {
5676       {
5677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5678       };
5679     } catch (std::exception& e) {
5680       {
5681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5682       };
5683     } catch (...) {
5684       {
5685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5686       };
5687     }
5688   }
5689   jresult = (void *)result;
5690   return jresult;
5691 }
5692
5693
5694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5695   void * jresult ;
5696   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5697   Dali::Vector3 *arg2 = 0 ;
5698   Dali::Vector3 result;
5699
5700   arg1 = (Dali::Vector3 *)jarg1;
5701   arg2 = (Dali::Vector3 *)jarg2;
5702   if (!arg2) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5709     } catch (std::out_of_range& e) {
5710       {
5711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (std::exception& e) {
5714       {
5715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5724   return jresult;
5725 }
5726
5727
5728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5729   void * jresult ;
5730   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5731   float arg2 ;
5732   Dali::Vector3 result;
5733
5734   arg1 = (Dali::Vector3 *)jarg1;
5735   arg2 = (float)jarg2;
5736   {
5737     try {
5738       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (...) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5750       };
5751     }
5752   }
5753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5759   void * jresult ;
5760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5761   Dali::Vector3 *arg2 = 0 ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   arg1 = (Dali::Vector3 *)jarg1;
5765   arg2 = (Dali::Vector3 *)jarg2;
5766   if (!arg2) {
5767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5768     return 0;
5769   }
5770   {
5771     try {
5772       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5773     } catch (std::out_of_range& e) {
5774       {
5775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5776       };
5777     } catch (std::exception& e) {
5778       {
5779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5780       };
5781     } catch (...) {
5782       {
5783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5784       };
5785     }
5786   }
5787   jresult = (void *)result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5793   void * jresult ;
5794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5795   float arg2 ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   arg1 = (Dali::Vector3 *)jarg1;
5799   arg2 = (float)jarg2;
5800   {
5801     try {
5802       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5803     } catch (std::out_of_range& e) {
5804       {
5805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5806       };
5807     } catch (std::exception& e) {
5808       {
5809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5810       };
5811     } catch (...) {
5812       {
5813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5814       };
5815     }
5816   }
5817   jresult = (void *)result;
5818   return jresult;
5819 }
5820
5821
5822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5823   void * jresult ;
5824   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5825   Dali::Vector3 result;
5826
5827   arg1 = (Dali::Vector3 *)jarg1;
5828   {
5829     try {
5830       result = ((Dali::Vector3 const *)arg1)->operator -();
5831     } catch (std::out_of_range& e) {
5832       {
5833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5834       };
5835     } catch (std::exception& e) {
5836       {
5837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5838       };
5839     } catch (...) {
5840       {
5841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5842       };
5843     }
5844   }
5845   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5851   unsigned int jresult ;
5852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5853   Dali::Vector3 *arg2 = 0 ;
5854   bool result;
5855
5856   arg1 = (Dali::Vector3 *)jarg1;
5857   arg2 = (Dali::Vector3 *)jarg2;
5858   if (!arg2) {
5859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5860     return 0;
5861   }
5862   {
5863     try {
5864       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5865     } catch (std::out_of_range& e) {
5866       {
5867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5868       };
5869     } catch (std::exception& e) {
5870       {
5871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (...) {
5874       {
5875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5876       };
5877     }
5878   }
5879   jresult = result;
5880   return jresult;
5881 }
5882
5883
5884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5885   unsigned int jresult ;
5886   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5887   Dali::Vector3 *arg2 = 0 ;
5888   bool result;
5889
5890   arg1 = (Dali::Vector3 *)jarg1;
5891   arg2 = (Dali::Vector3 *)jarg2;
5892   if (!arg2) {
5893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5894     return 0;
5895   }
5896   {
5897     try {
5898       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5899     } catch (std::out_of_range& e) {
5900       {
5901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (std::exception& e) {
5904       {
5905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913   jresult = result;
5914   return jresult;
5915 }
5916
5917
5918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5919   float jresult ;
5920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5921   unsigned int arg2 ;
5922   float *result = 0 ;
5923
5924   arg1 = (Dali::Vector3 *)jarg1;
5925   arg2 = (unsigned int)jarg2;
5926   {
5927     try {
5928       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (...) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5940       };
5941     }
5942   }
5943   jresult = *result;
5944   return jresult;
5945 }
5946
5947
5948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5949   float jresult ;
5950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5951   Dali::Vector3 *arg2 = 0 ;
5952   float result;
5953
5954   arg1 = (Dali::Vector3 *)jarg1;
5955   arg2 = (Dali::Vector3 *)jarg2;
5956   if (!arg2) {
5957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5958     return 0;
5959   }
5960   {
5961     try {
5962       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5963     } catch (std::out_of_range& e) {
5964       {
5965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5966       };
5967     } catch (std::exception& e) {
5968       {
5969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5970       };
5971     } catch (...) {
5972       {
5973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5974       };
5975     }
5976   }
5977   jresult = result;
5978   return jresult;
5979 }
5980
5981
5982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5983   void * jresult ;
5984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5985   Dali::Vector3 *arg2 = 0 ;
5986   Dali::Vector3 result;
5987
5988   arg1 = (Dali::Vector3 *)jarg1;
5989   arg2 = (Dali::Vector3 *)jarg2;
5990   if (!arg2) {
5991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5992     return 0;
5993   }
5994   {
5995     try {
5996       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5997     } catch (std::out_of_range& e) {
5998       {
5999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6000       };
6001     } catch (std::exception& e) {
6002       {
6003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6004       };
6005     } catch (...) {
6006       {
6007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6008       };
6009     }
6010   }
6011   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6012   return jresult;
6013 }
6014
6015
6016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6017   float jresult ;
6018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6019   float result;
6020
6021   arg1 = (Dali::Vector3 *)jarg1;
6022   {
6023     try {
6024       result = (float)((Dali::Vector3 const *)arg1)->Length();
6025     } catch (std::out_of_range& e) {
6026       {
6027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6028       };
6029     } catch (std::exception& e) {
6030       {
6031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6032       };
6033     } catch (...) {
6034       {
6035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6036       };
6037     }
6038   }
6039   jresult = result;
6040   return jresult;
6041 }
6042
6043
6044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6045   float jresult ;
6046   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6047   float result;
6048
6049   arg1 = (Dali::Vector3 *)jarg1;
6050   {
6051     try {
6052       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6053     } catch (std::out_of_range& e) {
6054       {
6055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (std::exception& e) {
6058       {
6059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6060       };
6061     } catch (...) {
6062       {
6063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6064       };
6065     }
6066   }
6067   jresult = result;
6068   return jresult;
6069 }
6070
6071
6072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6073   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6074
6075   arg1 = (Dali::Vector3 *)jarg1;
6076   {
6077     try {
6078       (arg1)->Normalize();
6079     } catch (std::out_of_range& e) {
6080       {
6081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6082       };
6083     } catch (std::exception& e) {
6084       {
6085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6086       };
6087     } catch (...) {
6088       {
6089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6090       };
6091     }
6092   }
6093 }
6094
6095
6096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6098   Dali::Vector3 *arg2 = 0 ;
6099   Dali::Vector3 *arg3 = 0 ;
6100
6101   arg1 = (Dali::Vector3 *)jarg1;
6102   arg2 = (Dali::Vector3 *)jarg2;
6103   if (!arg2) {
6104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6105     return ;
6106   }
6107   arg3 = (Dali::Vector3 *)jarg3;
6108   if (!arg3) {
6109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6110     return ;
6111   }
6112   {
6113     try {
6114       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6115     } catch (std::out_of_range& e) {
6116       {
6117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6118       };
6119     } catch (std::exception& e) {
6120       {
6121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6122       };
6123     } catch (...) {
6124       {
6125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6126       };
6127     }
6128   }
6129 }
6130
6131
6132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6133   void * jresult ;
6134   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6135   float *result = 0 ;
6136
6137   arg1 = (Dali::Vector3 *)jarg1;
6138   {
6139     try {
6140       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6141     } catch (std::out_of_range& e) {
6142       {
6143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (std::exception& e) {
6146       {
6147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6148       };
6149     } catch (...) {
6150       {
6151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6152       };
6153     }
6154   }
6155   jresult = (void *)result;
6156   return jresult;
6157 }
6158
6159
6160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6161   void * jresult ;
6162   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6163   Dali::Vector2 *result = 0 ;
6164
6165   arg1 = (Dali::Vector3 *)jarg1;
6166   {
6167     try {
6168       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6169     } catch (std::out_of_range& e) {
6170       {
6171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (std::exception& e) {
6174       {
6175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183   jresult = (void *)result;
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector2 *result = 0 ;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   {
6195     try {
6196       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6197     } catch (std::out_of_range& e) {
6198       {
6199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6200       };
6201     } catch (std::exception& e) {
6202       {
6203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6204       };
6205     } catch (...) {
6206       {
6207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6208       };
6209     }
6210   }
6211   jresult = (void *)result;
6212   return jresult;
6213 }
6214
6215
6216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6217   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6218   float arg2 ;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   arg2 = (float)jarg2;
6222   if (arg1) (arg1)->x = arg2;
6223 }
6224
6225
6226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6227   float jresult ;
6228   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6229   float result;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   result = (float) ((arg1)->x);
6233   jresult = result;
6234   return jresult;
6235 }
6236
6237
6238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6240   float arg2 ;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   arg2 = (float)jarg2;
6244   if (arg1) (arg1)->width = arg2;
6245 }
6246
6247
6248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6249   float jresult ;
6250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6251   float result;
6252
6253   arg1 = (Dali::Vector3 *)jarg1;
6254   result = (float) ((arg1)->width);
6255   jresult = result;
6256   return jresult;
6257 }
6258
6259
6260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   float arg2 ;
6263
6264   arg1 = (Dali::Vector3 *)jarg1;
6265   arg2 = (float)jarg2;
6266   if (arg1) (arg1)->r = arg2;
6267 }
6268
6269
6270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6271   float jresult ;
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   float result;
6274
6275   arg1 = (Dali::Vector3 *)jarg1;
6276   result = (float) ((arg1)->r);
6277   jresult = result;
6278   return jresult;
6279 }
6280
6281
6282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6284   float arg2 ;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   arg2 = (float)jarg2;
6288   if (arg1) (arg1)->y = arg2;
6289 }
6290
6291
6292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6293   float jresult ;
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float result;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   result = (float) ((arg1)->y);
6299   jresult = result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   float arg2 ;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (float)jarg2;
6310   if (arg1) (arg1)->height = arg2;
6311 }
6312
6313
6314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6315   float jresult ;
6316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6317   float result;
6318
6319   arg1 = (Dali::Vector3 *)jarg1;
6320   result = (float) ((arg1)->height);
6321   jresult = result;
6322   return jresult;
6323 }
6324
6325
6326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6328   float arg2 ;
6329
6330   arg1 = (Dali::Vector3 *)jarg1;
6331   arg2 = (float)jarg2;
6332   if (arg1) (arg1)->g = arg2;
6333 }
6334
6335
6336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6337   float jresult ;
6338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6339   float result;
6340
6341   arg1 = (Dali::Vector3 *)jarg1;
6342   result = (float) ((arg1)->g);
6343   jresult = result;
6344   return jresult;
6345 }
6346
6347
6348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6349   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6350   float arg2 ;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   arg2 = (float)jarg2;
6354   if (arg1) (arg1)->z = arg2;
6355 }
6356
6357
6358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6359   float jresult ;
6360   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6361   float result;
6362
6363   arg1 = (Dali::Vector3 *)jarg1;
6364   result = (float) ((arg1)->z);
6365   jresult = result;
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6371   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6372   float arg2 ;
6373
6374   arg1 = (Dali::Vector3 *)jarg1;
6375   arg2 = (float)jarg2;
6376   if (arg1) (arg1)->depth = arg2;
6377 }
6378
6379
6380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6381   float jresult ;
6382   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6383   float result;
6384
6385   arg1 = (Dali::Vector3 *)jarg1;
6386   result = (float) ((arg1)->depth);
6387   jresult = result;
6388   return jresult;
6389 }
6390
6391
6392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6393   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6394   float arg2 ;
6395
6396   arg1 = (Dali::Vector3 *)jarg1;
6397   arg2 = (float)jarg2;
6398   if (arg1) (arg1)->b = arg2;
6399 }
6400
6401
6402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6403   float jresult ;
6404   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6405   float result;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   result = (float) ((arg1)->b);
6409   jresult = result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6415   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6416
6417   arg1 = (Dali::Vector3 *)jarg1;
6418   {
6419     try {
6420       delete arg1;
6421     } catch (std::out_of_range& e) {
6422       {
6423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6424       };
6425     } catch (std::exception& e) {
6426       {
6427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6428       };
6429     } catch (...) {
6430       {
6431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6432       };
6433     }
6434   }
6435 }
6436
6437
6438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6439   void * jresult ;
6440   Dali::Vector3 *arg1 = 0 ;
6441   Dali::Vector3 *arg2 = 0 ;
6442   Dali::Vector3 result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   if (!arg1) {
6446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6447     return 0;
6448   }
6449   arg2 = (Dali::Vector3 *)jarg2;
6450   if (!arg2) {
6451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6452     return 0;
6453   }
6454   {
6455     try {
6456       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6457     } catch (std::out_of_range& e) {
6458       {
6459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (std::exception& e) {
6462       {
6463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6477   void * jresult ;
6478   Dali::Vector3 *arg1 = 0 ;
6479   Dali::Vector3 *arg2 = 0 ;
6480   Dali::Vector3 result;
6481
6482   arg1 = (Dali::Vector3 *)jarg1;
6483   if (!arg1) {
6484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6485     return 0;
6486   }
6487   arg2 = (Dali::Vector3 *)jarg2;
6488   if (!arg2) {
6489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6490     return 0;
6491   }
6492   {
6493     try {
6494       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6495     } catch (std::out_of_range& e) {
6496       {
6497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6498       };
6499     } catch (std::exception& e) {
6500       {
6501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (...) {
6504       {
6505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6506       };
6507     }
6508   }
6509   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6510   return jresult;
6511 }
6512
6513
6514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6515   void * jresult ;
6516   Dali::Vector3 *arg1 = 0 ;
6517   float *arg2 = 0 ;
6518   float *arg3 = 0 ;
6519   float temp2 ;
6520   float temp3 ;
6521   Dali::Vector3 result;
6522
6523   arg1 = (Dali::Vector3 *)jarg1;
6524   if (!arg1) {
6525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6526     return 0;
6527   }
6528   temp2 = (float)jarg2;
6529   arg2 = &temp2;
6530   temp3 = (float)jarg3;
6531   arg3 = &temp3;
6532   {
6533     try {
6534       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6535     } catch (std::out_of_range& e) {
6536       {
6537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (std::exception& e) {
6540       {
6541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6550   return jresult;
6551 }
6552
6553
6554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6555   void * jresult ;
6556   Dali::Vector4 *result = 0 ;
6557
6558   {
6559     try {
6560       result = (Dali::Vector4 *)new Dali::Vector4();
6561     } catch (std::out_of_range& e) {
6562       {
6563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6564       };
6565     } catch (std::exception& e) {
6566       {
6567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (...) {
6570       {
6571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6572       };
6573     }
6574   }
6575   jresult = (void *)result;
6576   return jresult;
6577 }
6578
6579
6580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6581   void * jresult ;
6582   float arg1 ;
6583   float arg2 ;
6584   float arg3 ;
6585   float arg4 ;
6586   Dali::Vector4 *result = 0 ;
6587
6588   arg1 = (float)jarg1;
6589   arg2 = (float)jarg2;
6590   arg3 = (float)jarg3;
6591   arg4 = (float)jarg4;
6592   {
6593     try {
6594       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6595     } catch (std::out_of_range& e) {
6596       {
6597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6598       };
6599     } catch (std::exception& e) {
6600       {
6601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6602       };
6603     } catch (...) {
6604       {
6605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6606       };
6607     }
6608   }
6609   jresult = (void *)result;
6610   return jresult;
6611 }
6612
6613
6614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6615   void * jresult ;
6616   float *arg1 = (float *) 0 ;
6617   Dali::Vector4 *result = 0 ;
6618
6619   arg1 = jarg1;
6620   {
6621     try {
6622       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6623     } catch (std::out_of_range& e) {
6624       {
6625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6626       };
6627     } catch (std::exception& e) {
6628       {
6629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6630       };
6631     } catch (...) {
6632       {
6633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6634       };
6635     }
6636   }
6637   jresult = (void *)result;
6638
6639
6640   return jresult;
6641 }
6642
6643
6644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6645   void * jresult ;
6646   Dali::Vector2 *arg1 = 0 ;
6647   Dali::Vector4 *result = 0 ;
6648
6649   arg1 = (Dali::Vector2 *)jarg1;
6650   if (!arg1) {
6651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6652     return 0;
6653   }
6654   {
6655     try {
6656       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6657     } catch (std::out_of_range& e) {
6658       {
6659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6660       };
6661     } catch (std::exception& e) {
6662       {
6663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6664       };
6665     } catch (...) {
6666       {
6667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6668       };
6669     }
6670   }
6671   jresult = (void *)result;
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6677   void * jresult ;
6678   Dali::Vector3 *arg1 = 0 ;
6679   Dali::Vector4 *result = 0 ;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   if (!arg1) {
6683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6684     return 0;
6685   }
6686   {
6687     try {
6688       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6689     } catch (std::out_of_range& e) {
6690       {
6691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (std::exception& e) {
6694       {
6695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703   jresult = (void *)result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6709   void * jresult ;
6710   Dali::Vector4 *result = 0 ;
6711
6712   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6713   jresult = (void *)result;
6714   return jresult;
6715 }
6716
6717
6718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6719   void * jresult ;
6720   Dali::Vector4 *result = 0 ;
6721
6722   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6729   void * jresult ;
6730   Dali::Vector4 *result = 0 ;
6731
6732   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6739   void * jresult ;
6740   Dali::Vector4 *result = 0 ;
6741
6742   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6743   jresult = (void *)result;
6744   return jresult;
6745 }
6746
6747
6748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6749   void * jresult ;
6750   Dali::Vector4 *result = 0 ;
6751
6752   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6753   jresult = (void *)result;
6754   return jresult;
6755 }
6756
6757
6758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6759   void * jresult ;
6760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6761   float *arg2 = (float *) 0 ;
6762   Dali::Vector4 *result = 0 ;
6763
6764   arg1 = (Dali::Vector4 *)jarg1;
6765   arg2 = jarg2;
6766   {
6767     try {
6768       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6769     } catch (std::out_of_range& e) {
6770       {
6771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6772       };
6773     } catch (std::exception& e) {
6774       {
6775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6776       };
6777     } catch (...) {
6778       {
6779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6780       };
6781     }
6782   }
6783   jresult = (void *)result;
6784
6785
6786   return jresult;
6787 }
6788
6789
6790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6791   void * jresult ;
6792   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6793   Dali::Vector2 *arg2 = 0 ;
6794   Dali::Vector4 *result = 0 ;
6795
6796   arg1 = (Dali::Vector4 *)jarg1;
6797   arg2 = (Dali::Vector2 *)jarg2;
6798   if (!arg2) {
6799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6800     return 0;
6801   }
6802   {
6803     try {
6804       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6805     } catch (std::out_of_range& e) {
6806       {
6807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6808       };
6809     } catch (std::exception& e) {
6810       {
6811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6812       };
6813     } catch (...) {
6814       {
6815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6816       };
6817     }
6818   }
6819   jresult = (void *)result;
6820   return jresult;
6821 }
6822
6823
6824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6825   void * jresult ;
6826   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6827   Dali::Vector3 *arg2 = 0 ;
6828   Dali::Vector4 *result = 0 ;
6829
6830   arg1 = (Dali::Vector4 *)jarg1;
6831   arg2 = (Dali::Vector3 *)jarg2;
6832   if (!arg2) {
6833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6834     return 0;
6835   }
6836   {
6837     try {
6838       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6839     } catch (std::out_of_range& e) {
6840       {
6841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6842       };
6843     } catch (std::exception& e) {
6844       {
6845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6846       };
6847     } catch (...) {
6848       {
6849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6850       };
6851     }
6852   }
6853   jresult = (void *)result;
6854   return jresult;
6855 }
6856
6857
6858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6859   void * jresult ;
6860   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6861   Dali::Vector4 *arg2 = 0 ;
6862   Dali::Vector4 result;
6863
6864   arg1 = (Dali::Vector4 *)jarg1;
6865   arg2 = (Dali::Vector4 *)jarg2;
6866   if (!arg2) {
6867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6868     return 0;
6869   }
6870   {
6871     try {
6872       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6873     } catch (std::out_of_range& e) {
6874       {
6875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6876       };
6877     } catch (std::exception& e) {
6878       {
6879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6880       };
6881     } catch (...) {
6882       {
6883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6884       };
6885     }
6886   }
6887   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6888   return jresult;
6889 }
6890
6891
6892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6893   void * jresult ;
6894   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6895   Dali::Vector4 *arg2 = 0 ;
6896   Dali::Vector4 *result = 0 ;
6897
6898   arg1 = (Dali::Vector4 *)jarg1;
6899   arg2 = (Dali::Vector4 *)jarg2;
6900   if (!arg2) {
6901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6902     return 0;
6903   }
6904   {
6905     try {
6906       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6907     } catch (std::out_of_range& e) {
6908       {
6909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6910       };
6911     } catch (std::exception& e) {
6912       {
6913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6914       };
6915     } catch (...) {
6916       {
6917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6918       };
6919     }
6920   }
6921   jresult = (void *)result;
6922   return jresult;
6923 }
6924
6925
6926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6927   void * jresult ;
6928   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6929   Dali::Vector4 *arg2 = 0 ;
6930   Dali::Vector4 result;
6931
6932   arg1 = (Dali::Vector4 *)jarg1;
6933   arg2 = (Dali::Vector4 *)jarg2;
6934   if (!arg2) {
6935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6936     return 0;
6937   }
6938   {
6939     try {
6940       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6941     } catch (std::out_of_range& e) {
6942       {
6943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6944       };
6945     } catch (std::exception& e) {
6946       {
6947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6948       };
6949     } catch (...) {
6950       {
6951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6952       };
6953     }
6954   }
6955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6956   return jresult;
6957 }
6958
6959
6960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6961   void * jresult ;
6962   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6963   Dali::Vector4 *arg2 = 0 ;
6964   Dali::Vector4 *result = 0 ;
6965
6966   arg1 = (Dali::Vector4 *)jarg1;
6967   arg2 = (Dali::Vector4 *)jarg2;
6968   if (!arg2) {
6969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6970     return 0;
6971   }
6972   {
6973     try {
6974       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6975     } catch (std::out_of_range& e) {
6976       {
6977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6978       };
6979     } catch (std::exception& e) {
6980       {
6981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6982       };
6983     } catch (...) {
6984       {
6985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6986       };
6987     }
6988   }
6989   jresult = (void *)result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6995   void * jresult ;
6996   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6997   Dali::Vector4 *arg2 = 0 ;
6998   Dali::Vector4 result;
6999
7000   arg1 = (Dali::Vector4 *)jarg1;
7001   arg2 = (Dali::Vector4 *)jarg2;
7002   if (!arg2) {
7003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7004     return 0;
7005   }
7006   {
7007     try {
7008       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7009     } catch (std::out_of_range& e) {
7010       {
7011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7012       };
7013     } catch (std::exception& e) {
7014       {
7015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7016       };
7017     } catch (...) {
7018       {
7019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7020       };
7021     }
7022   }
7023   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7024   return jresult;
7025 }
7026
7027
7028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7029   void * jresult ;
7030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7031   float arg2 ;
7032   Dali::Vector4 result;
7033
7034   arg1 = (Dali::Vector4 *)jarg1;
7035   arg2 = (float)jarg2;
7036   {
7037     try {
7038       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7039     } catch (std::out_of_range& e) {
7040       {
7041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7042       };
7043     } catch (std::exception& e) {
7044       {
7045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7046       };
7047     } catch (...) {
7048       {
7049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7050       };
7051     }
7052   }
7053   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7054   return jresult;
7055 }
7056
7057
7058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7059   void * jresult ;
7060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7061   Dali::Vector4 *arg2 = 0 ;
7062   Dali::Vector4 *result = 0 ;
7063
7064   arg1 = (Dali::Vector4 *)jarg1;
7065   arg2 = (Dali::Vector4 *)jarg2;
7066   if (!arg2) {
7067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7068     return 0;
7069   }
7070   {
7071     try {
7072       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7073     } catch (std::out_of_range& e) {
7074       {
7075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7076       };
7077     } catch (std::exception& e) {
7078       {
7079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7080       };
7081     } catch (...) {
7082       {
7083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7084       };
7085     }
7086   }
7087   jresult = (void *)result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7093   void * jresult ;
7094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7095   float arg2 ;
7096   Dali::Vector4 *result = 0 ;
7097
7098   arg1 = (Dali::Vector4 *)jarg1;
7099   arg2 = (float)jarg2;
7100   {
7101     try {
7102       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7103     } catch (std::out_of_range& e) {
7104       {
7105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7106       };
7107     } catch (std::exception& e) {
7108       {
7109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (...) {
7112       {
7113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7114       };
7115     }
7116   }
7117   jresult = (void *)result;
7118   return jresult;
7119 }
7120
7121
7122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7123   void * jresult ;
7124   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7125   Dali::Vector4 *arg2 = 0 ;
7126   Dali::Vector4 result;
7127
7128   arg1 = (Dali::Vector4 *)jarg1;
7129   arg2 = (Dali::Vector4 *)jarg2;
7130   if (!arg2) {
7131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7132     return 0;
7133   }
7134   {
7135     try {
7136       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7137     } catch (std::out_of_range& e) {
7138       {
7139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7140       };
7141     } catch (std::exception& e) {
7142       {
7143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (...) {
7146       {
7147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7148       };
7149     }
7150   }
7151   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7152   return jresult;
7153 }
7154
7155
7156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7157   void * jresult ;
7158   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7159   float arg2 ;
7160   Dali::Vector4 result;
7161
7162   arg1 = (Dali::Vector4 *)jarg1;
7163   arg2 = (float)jarg2;
7164   {
7165     try {
7166       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (...) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7178       };
7179     }
7180   }
7181   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7187   void * jresult ;
7188   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7189   Dali::Vector4 *arg2 = 0 ;
7190   Dali::Vector4 *result = 0 ;
7191
7192   arg1 = (Dali::Vector4 *)jarg1;
7193   arg2 = (Dali::Vector4 *)jarg2;
7194   if (!arg2) {
7195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7196     return 0;
7197   }
7198   {
7199     try {
7200       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7201     } catch (std::out_of_range& e) {
7202       {
7203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (std::exception& e) {
7206       {
7207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215   jresult = (void *)result;
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7221   void * jresult ;
7222   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7223   float arg2 ;
7224   Dali::Vector4 *result = 0 ;
7225
7226   arg1 = (Dali::Vector4 *)jarg1;
7227   arg2 = (float)jarg2;
7228   {
7229     try {
7230       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7231     } catch (std::out_of_range& e) {
7232       {
7233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7234       };
7235     } catch (std::exception& e) {
7236       {
7237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7238       };
7239     } catch (...) {
7240       {
7241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7242       };
7243     }
7244   }
7245   jresult = (void *)result;
7246   return jresult;
7247 }
7248
7249
7250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7251   void * jresult ;
7252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7253   Dali::Vector4 result;
7254
7255   arg1 = (Dali::Vector4 *)jarg1;
7256   {
7257     try {
7258       result = ((Dali::Vector4 const *)arg1)->operator -();
7259     } catch (std::out_of_range& e) {
7260       {
7261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7262       };
7263     } catch (std::exception& e) {
7264       {
7265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7266       };
7267     } catch (...) {
7268       {
7269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7270       };
7271     }
7272   }
7273   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7274   return jresult;
7275 }
7276
7277
7278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7279   unsigned int jresult ;
7280   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7281   Dali::Vector4 *arg2 = 0 ;
7282   bool result;
7283
7284   arg1 = (Dali::Vector4 *)jarg1;
7285   arg2 = (Dali::Vector4 *)jarg2;
7286   if (!arg2) {
7287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7288     return 0;
7289   }
7290   {
7291     try {
7292       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7293     } catch (std::out_of_range& e) {
7294       {
7295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7296       };
7297     } catch (std::exception& e) {
7298       {
7299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7300       };
7301     } catch (...) {
7302       {
7303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7304       };
7305     }
7306   }
7307   jresult = result;
7308   return jresult;
7309 }
7310
7311
7312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7313   unsigned int jresult ;
7314   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7315   Dali::Vector4 *arg2 = 0 ;
7316   bool result;
7317
7318   arg1 = (Dali::Vector4 *)jarg1;
7319   arg2 = (Dali::Vector4 *)jarg2;
7320   if (!arg2) {
7321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7322     return 0;
7323   }
7324   {
7325     try {
7326       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7327     } catch (std::out_of_range& e) {
7328       {
7329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7330       };
7331     } catch (std::exception& e) {
7332       {
7333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7334       };
7335     } catch (...) {
7336       {
7337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7338       };
7339     }
7340   }
7341   jresult = result;
7342   return jresult;
7343 }
7344
7345
7346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7347   float jresult ;
7348   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7349   unsigned int arg2 ;
7350   float *result = 0 ;
7351
7352   arg1 = (Dali::Vector4 *)jarg1;
7353   arg2 = (unsigned int)jarg2;
7354   {
7355     try {
7356       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7357     } catch (std::out_of_range& e) {
7358       {
7359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7360       };
7361     } catch (std::exception& e) {
7362       {
7363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7364       };
7365     } catch (...) {
7366       {
7367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7368       };
7369     }
7370   }
7371   jresult = *result;
7372   return jresult;
7373 }
7374
7375
7376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7377   float jresult ;
7378   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7379   Dali::Vector3 *arg2 = 0 ;
7380   float result;
7381
7382   arg1 = (Dali::Vector4 *)jarg1;
7383   arg2 = (Dali::Vector3 *)jarg2;
7384   if (!arg2) {
7385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7386     return 0;
7387   }
7388   {
7389     try {
7390       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7391     } catch (std::out_of_range& e) {
7392       {
7393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (std::exception& e) {
7396       {
7397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405   jresult = result;
7406   return jresult;
7407 }
7408
7409
7410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7411   float jresult ;
7412   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7413   Dali::Vector4 *arg2 = 0 ;
7414   float result;
7415
7416   arg1 = (Dali::Vector4 *)jarg1;
7417   arg2 = (Dali::Vector4 *)jarg2;
7418   if (!arg2) {
7419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7420     return 0;
7421   }
7422   {
7423     try {
7424       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7425     } catch (std::out_of_range& e) {
7426       {
7427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (std::exception& e) {
7430       {
7431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439   jresult = result;
7440   return jresult;
7441 }
7442
7443
7444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7445   float jresult ;
7446   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7447   Dali::Vector4 *arg2 = 0 ;
7448   float result;
7449
7450   arg1 = (Dali::Vector4 *)jarg1;
7451   arg2 = (Dali::Vector4 *)jarg2;
7452   if (!arg2) {
7453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7454     return 0;
7455   }
7456   {
7457     try {
7458       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7459     } catch (std::out_of_range& e) {
7460       {
7461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7462       };
7463     } catch (std::exception& e) {
7464       {
7465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7466       };
7467     } catch (...) {
7468       {
7469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7470       };
7471     }
7472   }
7473   jresult = result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7479   void * jresult ;
7480   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7481   Dali::Vector4 *arg2 = 0 ;
7482   Dali::Vector4 result;
7483
7484   arg1 = (Dali::Vector4 *)jarg1;
7485   arg2 = (Dali::Vector4 *)jarg2;
7486   if (!arg2) {
7487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7488     return 0;
7489   }
7490   {
7491     try {
7492       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7493     } catch (std::out_of_range& e) {
7494       {
7495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (std::exception& e) {
7498       {
7499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7500       };
7501     } catch (...) {
7502       {
7503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7504       };
7505     }
7506   }
7507   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7508   return jresult;
7509 }
7510
7511
7512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7513   float jresult ;
7514   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7515   float result;
7516
7517   arg1 = (Dali::Vector4 *)jarg1;
7518   {
7519     try {
7520       result = (float)((Dali::Vector4 const *)arg1)->Length();
7521     } catch (std::out_of_range& e) {
7522       {
7523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7524       };
7525     } catch (std::exception& e) {
7526       {
7527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7528       };
7529     } catch (...) {
7530       {
7531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7532       };
7533     }
7534   }
7535   jresult = result;
7536   return jresult;
7537 }
7538
7539
7540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7541   float jresult ;
7542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7543   float result;
7544
7545   arg1 = (Dali::Vector4 *)jarg1;
7546   {
7547     try {
7548       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7549     } catch (std::out_of_range& e) {
7550       {
7551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (std::exception& e) {
7554       {
7555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7556       };
7557     } catch (...) {
7558       {
7559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7560       };
7561     }
7562   }
7563   jresult = result;
7564   return jresult;
7565 }
7566
7567
7568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7569   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7570
7571   arg1 = (Dali::Vector4 *)jarg1;
7572   {
7573     try {
7574       (arg1)->Normalize();
7575     } catch (std::out_of_range& e) {
7576       {
7577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7578       };
7579     } catch (std::exception& e) {
7580       {
7581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7582       };
7583     } catch (...) {
7584       {
7585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7586       };
7587     }
7588   }
7589 }
7590
7591
7592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7593   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7594   Dali::Vector4 *arg2 = 0 ;
7595   Dali::Vector4 *arg3 = 0 ;
7596
7597   arg1 = (Dali::Vector4 *)jarg1;
7598   arg2 = (Dali::Vector4 *)jarg2;
7599   if (!arg2) {
7600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7601     return ;
7602   }
7603   arg3 = (Dali::Vector4 *)jarg3;
7604   if (!arg3) {
7605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7606     return ;
7607   }
7608   {
7609     try {
7610       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7611     } catch (std::out_of_range& e) {
7612       {
7613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7614       };
7615     } catch (std::exception& e) {
7616       {
7617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7618       };
7619     } catch (...) {
7620       {
7621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7622       };
7623     }
7624   }
7625 }
7626
7627
7628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7629   void * jresult ;
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   float *result = 0 ;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   {
7635     try {
7636       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7637     } catch (std::out_of_range& e) {
7638       {
7639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7640       };
7641     } catch (std::exception& e) {
7642       {
7643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7644       };
7645     } catch (...) {
7646       {
7647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7648       };
7649     }
7650   }
7651   jresult = (void *)result;
7652   return jresult;
7653 }
7654
7655
7656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7658   float arg2 ;
7659
7660   arg1 = (Dali::Vector4 *)jarg1;
7661   arg2 = (float)jarg2;
7662   if (arg1) (arg1)->x = arg2;
7663 }
7664
7665
7666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7667   float jresult ;
7668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7669   float result;
7670
7671   arg1 = (Dali::Vector4 *)jarg1;
7672   result = (float) ((arg1)->x);
7673   jresult = result;
7674   return jresult;
7675 }
7676
7677
7678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7680   float arg2 ;
7681
7682   arg1 = (Dali::Vector4 *)jarg1;
7683   arg2 = (float)jarg2;
7684   if (arg1) (arg1)->r = arg2;
7685 }
7686
7687
7688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7689   float jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   float result;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   result = (float) ((arg1)->r);
7695   jresult = result;
7696   return jresult;
7697 }
7698
7699
7700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7702   float arg2 ;
7703
7704   arg1 = (Dali::Vector4 *)jarg1;
7705   arg2 = (float)jarg2;
7706   if (arg1) (arg1)->s = arg2;
7707 }
7708
7709
7710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7711   float jresult ;
7712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7713   float result;
7714
7715   arg1 = (Dali::Vector4 *)jarg1;
7716   result = (float) ((arg1)->s);
7717   jresult = result;
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   float arg2 ;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   arg2 = (float)jarg2;
7728   if (arg1) (arg1)->y = arg2;
7729 }
7730
7731
7732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7733   float jresult ;
7734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7735   float result;
7736
7737   arg1 = (Dali::Vector4 *)jarg1;
7738   result = (float) ((arg1)->y);
7739   jresult = result;
7740   return jresult;
7741 }
7742
7743
7744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7746   float arg2 ;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   arg2 = (float)jarg2;
7750   if (arg1) (arg1)->g = arg2;
7751 }
7752
7753
7754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7755   float jresult ;
7756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7757   float result;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   result = (float) ((arg1)->g);
7761   jresult = result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   float arg2 ;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   arg2 = (float)jarg2;
7772   if (arg1) (arg1)->t = arg2;
7773 }
7774
7775
7776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7777   float jresult ;
7778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7779   float result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   result = (float) ((arg1)->t);
7783   jresult = result;
7784   return jresult;
7785 }
7786
7787
7788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7790   float arg2 ;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   arg2 = (float)jarg2;
7794   if (arg1) (arg1)->z = arg2;
7795 }
7796
7797
7798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7799   float jresult ;
7800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7801   float result;
7802
7803   arg1 = (Dali::Vector4 *)jarg1;
7804   result = (float) ((arg1)->z);
7805   jresult = result;
7806   return jresult;
7807 }
7808
7809
7810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7812   float arg2 ;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   if (arg1) (arg1)->b = arg2;
7817 }
7818
7819
7820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7821   float jresult ;
7822   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7823   float result;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   result = (float) ((arg1)->b);
7827   jresult = result;
7828   return jresult;
7829 }
7830
7831
7832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float arg2 ;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   arg2 = (float)jarg2;
7838   if (arg1) (arg1)->p = arg2;
7839 }
7840
7841
7842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7843   float jresult ;
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845   float result;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   result = (float) ((arg1)->p);
7849   jresult = result;
7850   return jresult;
7851 }
7852
7853
7854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7855   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7856   float arg2 ;
7857
7858   arg1 = (Dali::Vector4 *)jarg1;
7859   arg2 = (float)jarg2;
7860   if (arg1) (arg1)->w = arg2;
7861 }
7862
7863
7864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7865   float jresult ;
7866   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7867   float result;
7868
7869   arg1 = (Dali::Vector4 *)jarg1;
7870   result = (float) ((arg1)->w);
7871   jresult = result;
7872   return jresult;
7873 }
7874
7875
7876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7877   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7878   float arg2 ;
7879
7880   arg1 = (Dali::Vector4 *)jarg1;
7881   arg2 = (float)jarg2;
7882   if (arg1) (arg1)->a = arg2;
7883 }
7884
7885
7886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7887   float jresult ;
7888   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7889   float result;
7890
7891   arg1 = (Dali::Vector4 *)jarg1;
7892   result = (float) ((arg1)->a);
7893   jresult = result;
7894   return jresult;
7895 }
7896
7897
7898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7899   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7900   float arg2 ;
7901
7902   arg1 = (Dali::Vector4 *)jarg1;
7903   arg2 = (float)jarg2;
7904   if (arg1) (arg1)->q = arg2;
7905 }
7906
7907
7908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7909   float jresult ;
7910   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7911   float result;
7912
7913   arg1 = (Dali::Vector4 *)jarg1;
7914   result = (float) ((arg1)->q);
7915   jresult = result;
7916   return jresult;
7917 }
7918
7919
7920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7921   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   {
7925     try {
7926       delete arg1;
7927     } catch (std::out_of_range& e) {
7928       {
7929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7930       };
7931     } catch (std::exception& e) {
7932       {
7933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7934       };
7935     } catch (...) {
7936       {
7937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7938       };
7939     }
7940   }
7941 }
7942
7943
7944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7945   void * jresult ;
7946   Dali::Vector4 *arg1 = 0 ;
7947   Dali::Vector4 *arg2 = 0 ;
7948   Dali::Vector4 result;
7949
7950   arg1 = (Dali::Vector4 *)jarg1;
7951   if (!arg1) {
7952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7953     return 0;
7954   }
7955   arg2 = (Dali::Vector4 *)jarg2;
7956   if (!arg2) {
7957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7958     return 0;
7959   }
7960   {
7961     try {
7962       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7963     } catch (std::out_of_range& e) {
7964       {
7965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (std::exception& e) {
7968       {
7969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7978   return jresult;
7979 }
7980
7981
7982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7983   void * jresult ;
7984   Dali::Vector4 *arg1 = 0 ;
7985   Dali::Vector4 *arg2 = 0 ;
7986   Dali::Vector4 result;
7987
7988   arg1 = (Dali::Vector4 *)jarg1;
7989   if (!arg1) {
7990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7991     return 0;
7992   }
7993   arg2 = (Dali::Vector4 *)jarg2;
7994   if (!arg2) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7996     return 0;
7997   }
7998   {
7999     try {
8000       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8001     } catch (std::out_of_range& e) {
8002       {
8003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8004       };
8005     } catch (std::exception& e) {
8006       {
8007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (...) {
8010       {
8011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8012       };
8013     }
8014   }
8015   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8016   return jresult;
8017 }
8018
8019
8020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8021   void * jresult ;
8022   Dali::Vector4 *arg1 = 0 ;
8023   float *arg2 = 0 ;
8024   float *arg3 = 0 ;
8025   float temp2 ;
8026   float temp3 ;
8027   Dali::Vector4 result;
8028
8029   arg1 = (Dali::Vector4 *)jarg1;
8030   if (!arg1) {
8031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8032     return 0;
8033   }
8034   temp2 = (float)jarg2;
8035   arg2 = &temp2;
8036   temp3 = (float)jarg3;
8037   arg3 = &temp3;
8038   {
8039     try {
8040       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (...) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8052       };
8053     }
8054   }
8055   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8056   return jresult;
8057 }
8058
8059
8060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8061   void * jresult ;
8062   Dali::Uint16Pair *result = 0 ;
8063
8064   {
8065     try {
8066       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8067     } catch (std::out_of_range& e) {
8068       {
8069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8070       };
8071     } catch (std::exception& e) {
8072       {
8073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (...) {
8076       {
8077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8078       };
8079     }
8080   }
8081   jresult = (void *)result;
8082   return jresult;
8083 }
8084
8085
8086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8087   void * jresult ;
8088   uint32_t arg1 ;
8089   uint32_t arg2 ;
8090   Dali::Uint16Pair *result = 0 ;
8091
8092   arg1 = (uint32_t)jarg1;
8093   arg2 = (uint32_t)jarg2;
8094   {
8095     try {
8096       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8104       };
8105     } catch (...) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8108       };
8109     }
8110   }
8111   jresult = (void *)result;
8112   return jresult;
8113 }
8114
8115
8116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8117   void * jresult ;
8118   Dali::Uint16Pair *arg1 = 0 ;
8119   Dali::Uint16Pair *result = 0 ;
8120
8121   arg1 = (Dali::Uint16Pair *)jarg1;
8122   if (!arg1) {
8123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8124     return 0;
8125   }
8126   {
8127     try {
8128       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8129     } catch (std::out_of_range& e) {
8130       {
8131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8132       };
8133     } catch (std::exception& e) {
8134       {
8135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8136       };
8137     } catch (...) {
8138       {
8139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8140       };
8141     }
8142   }
8143   jresult = (void *)result;
8144   return jresult;
8145 }
8146
8147
8148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8149   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8150   uint16_t arg2 ;
8151
8152   arg1 = (Dali::Uint16Pair *)jarg1;
8153   arg2 = (uint16_t)jarg2;
8154   {
8155     try {
8156       (arg1)->SetWidth(arg2);
8157     } catch (std::out_of_range& e) {
8158       {
8159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8160       };
8161     } catch (std::exception& e) {
8162       {
8163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8164       };
8165     } catch (...) {
8166       {
8167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8168       };
8169     }
8170   }
8171 }
8172
8173
8174 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8175   unsigned short jresult ;
8176   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8177   uint16_t result;
8178
8179   arg1 = (Dali::Uint16Pair *)jarg1;
8180   {
8181     try {
8182       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8183     } catch (std::out_of_range& e) {
8184       {
8185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (std::exception& e) {
8188       {
8189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197   jresult = result;
8198   return jresult;
8199 }
8200
8201
8202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8203   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8204   uint16_t arg2 ;
8205
8206   arg1 = (Dali::Uint16Pair *)jarg1;
8207   arg2 = (uint16_t)jarg2;
8208   {
8209     try {
8210       (arg1)->SetHeight(arg2);
8211     } catch (std::out_of_range& e) {
8212       {
8213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8214       };
8215     } catch (std::exception& e) {
8216       {
8217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8218       };
8219     } catch (...) {
8220       {
8221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8222       };
8223     }
8224   }
8225 }
8226
8227
8228 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8229   unsigned short jresult ;
8230   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8231   uint16_t result;
8232
8233   arg1 = (Dali::Uint16Pair *)jarg1;
8234   {
8235     try {
8236       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8237     } catch (std::out_of_range& e) {
8238       {
8239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8240       };
8241     } catch (std::exception& e) {
8242       {
8243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8244       };
8245     } catch (...) {
8246       {
8247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8248       };
8249     }
8250   }
8251   jresult = result;
8252   return jresult;
8253 }
8254
8255
8256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8257   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8258   uint16_t arg2 ;
8259
8260   arg1 = (Dali::Uint16Pair *)jarg1;
8261   arg2 = (uint16_t)jarg2;
8262   {
8263     try {
8264       (arg1)->SetX(arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8272       };
8273     } catch (...) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8276       };
8277     }
8278   }
8279 }
8280
8281
8282 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8283   unsigned short jresult ;
8284   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8285   uint16_t result;
8286
8287   arg1 = (Dali::Uint16Pair *)jarg1;
8288   {
8289     try {
8290       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8291     } catch (std::out_of_range& e) {
8292       {
8293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (std::exception& e) {
8296       {
8297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8298       };
8299     } catch (...) {
8300       {
8301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8302       };
8303     }
8304   }
8305   jresult = result;
8306   return jresult;
8307 }
8308
8309
8310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8311   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8312   uint16_t arg2 ;
8313
8314   arg1 = (Dali::Uint16Pair *)jarg1;
8315   arg2 = (uint16_t)jarg2;
8316   {
8317     try {
8318       (arg1)->SetY(arg2);
8319     } catch (std::out_of_range& e) {
8320       {
8321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8322       };
8323     } catch (std::exception& e) {
8324       {
8325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8326       };
8327     } catch (...) {
8328       {
8329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8330       };
8331     }
8332   }
8333 }
8334
8335
8336 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8337   unsigned short jresult ;
8338   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8339   uint16_t result;
8340
8341   arg1 = (Dali::Uint16Pair *)jarg1;
8342   {
8343     try {
8344       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8345     } catch (std::out_of_range& e) {
8346       {
8347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (std::exception& e) {
8350       {
8351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359   jresult = result;
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8365   void * jresult ;
8366   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8367   Dali::Uint16Pair *arg2 = 0 ;
8368   Dali::Uint16Pair *result = 0 ;
8369
8370   arg1 = (Dali::Uint16Pair *)jarg1;
8371   arg2 = (Dali::Uint16Pair *)jarg2;
8372   if (!arg2) {
8373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8374     return 0;
8375   }
8376   {
8377     try {
8378       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8379     } catch (std::out_of_range& e) {
8380       {
8381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8382       };
8383     } catch (std::exception& e) {
8384       {
8385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8386       };
8387     } catch (...) {
8388       {
8389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8390       };
8391     }
8392   }
8393   jresult = (void *)result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8399   unsigned int jresult ;
8400   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8401   Dali::Uint16Pair *arg2 = 0 ;
8402   bool result;
8403
8404   arg1 = (Dali::Uint16Pair *)jarg1;
8405   arg2 = (Dali::Uint16Pair *)jarg2;
8406   if (!arg2) {
8407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8408     return 0;
8409   }
8410   {
8411     try {
8412       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8413     } catch (std::out_of_range& e) {
8414       {
8415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (std::exception& e) {
8418       {
8419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427   jresult = result;
8428   return jresult;
8429 }
8430
8431
8432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8433   unsigned int jresult ;
8434   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8435   Dali::Uint16Pair *arg2 = 0 ;
8436   bool result;
8437
8438   arg1 = (Dali::Uint16Pair *)jarg1;
8439   arg2 = (Dali::Uint16Pair *)jarg2;
8440   if (!arg2) {
8441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8442     return 0;
8443   }
8444   {
8445     try {
8446       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8447     } catch (std::out_of_range& e) {
8448       {
8449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8450       };
8451     } catch (std::exception& e) {
8452       {
8453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8454       };
8455     } catch (...) {
8456       {
8457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8458       };
8459     }
8460   }
8461   jresult = result;
8462   return jresult;
8463 }
8464
8465
8466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8467   unsigned int jresult ;
8468   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8469   Dali::Uint16Pair *arg2 = 0 ;
8470   bool result;
8471
8472   arg1 = (Dali::Uint16Pair *)jarg1;
8473   arg2 = (Dali::Uint16Pair *)jarg2;
8474   if (!arg2) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8476     return 0;
8477   }
8478   {
8479     try {
8480       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8488       };
8489     } catch (...) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8492       };
8493     }
8494   }
8495   jresult = result;
8496   return jresult;
8497 }
8498
8499
8500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8501   unsigned int jresult ;
8502   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8503   Dali::Uint16Pair *arg2 = 0 ;
8504   bool result;
8505
8506   arg1 = (Dali::Uint16Pair *)jarg1;
8507   arg2 = (Dali::Uint16Pair *)jarg2;
8508   if (!arg2) {
8509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8510     return 0;
8511   }
8512   {
8513     try {
8514       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8515     } catch (std::out_of_range& e) {
8516       {
8517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (std::exception& e) {
8520       {
8521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8522       };
8523     } catch (...) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8526       };
8527     }
8528   }
8529   jresult = result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8535   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8536
8537   arg1 = (Dali::Uint16Pair *)jarg1;
8538   {
8539     try {
8540       delete arg1;
8541     } catch (std::out_of_range& e) {
8542       {
8543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8544       };
8545     } catch (std::exception& e) {
8546       {
8547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8548       };
8549     } catch (...) {
8550       {
8551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8552       };
8553     }
8554   }
8555 }
8556
8557
8558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8559   void * jresult ;
8560   Dali::Degree *result = 0 ;
8561
8562   {
8563     try {
8564       result = (Dali::Degree *)new Dali::Degree();
8565     } catch (std::out_of_range& e) {
8566       {
8567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8568       };
8569     } catch (std::exception& e) {
8570       {
8571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8572       };
8573     } catch (...) {
8574       {
8575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8576       };
8577     }
8578   }
8579   jresult = (void *)result;
8580   return jresult;
8581 }
8582
8583
8584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8585   void * jresult ;
8586   float arg1 ;
8587   Dali::Degree *result = 0 ;
8588
8589   arg1 = (float)jarg1;
8590   {
8591     try {
8592       result = (Dali::Degree *)new Dali::Degree(arg1);
8593     } catch (std::out_of_range& e) {
8594       {
8595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8596       };
8597     } catch (std::exception& e) {
8598       {
8599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8600       };
8601     } catch (...) {
8602       {
8603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8604       };
8605     }
8606   }
8607   jresult = (void *)result;
8608   return jresult;
8609 }
8610
8611
8612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8613   void * jresult ;
8614   Dali::Radian arg1 ;
8615   Dali::Radian *argp1 ;
8616   Dali::Degree *result = 0 ;
8617
8618   argp1 = (Dali::Radian *)jarg1;
8619   if (!argp1) {
8620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8621     return 0;
8622   }
8623   arg1 = *argp1;
8624   {
8625     try {
8626       result = (Dali::Degree *)new Dali::Degree(arg1);
8627     } catch (std::out_of_range& e) {
8628       {
8629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8630       };
8631     } catch (std::exception& e) {
8632       {
8633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8634       };
8635     } catch (...) {
8636       {
8637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8638       };
8639     }
8640   }
8641   jresult = (void *)result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Degree *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->degree = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Degree *)jarg1;
8662   result = (float) ((arg1)->degree);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8670
8671   arg1 = (Dali::Degree *)jarg1;
8672   {
8673     try {
8674       delete arg1;
8675     } catch (std::out_of_range& e) {
8676       {
8677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8678       };
8679     } catch (std::exception& e) {
8680       {
8681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8682       };
8683     } catch (...) {
8684       {
8685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8686       };
8687     }
8688   }
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8693   void * jresult ;
8694   Dali::Radian *result = 0 ;
8695
8696   result = (Dali::Radian *)&Dali::ANGLE_360;
8697   jresult = (void *)result;
8698   return jresult;
8699 }
8700
8701
8702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8703   void * jresult ;
8704   Dali::Radian *result = 0 ;
8705
8706   result = (Dali::Radian *)&Dali::ANGLE_315;
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_270;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_225;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8733   void * jresult ;
8734   Dali::Radian *result = 0 ;
8735
8736   result = (Dali::Radian *)&Dali::ANGLE_180;
8737   jresult = (void *)result;
8738   return jresult;
8739 }
8740
8741
8742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8743   void * jresult ;
8744   Dali::Radian *result = 0 ;
8745
8746   result = (Dali::Radian *)&Dali::ANGLE_135;
8747   jresult = (void *)result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8753   void * jresult ;
8754   Dali::Radian *result = 0 ;
8755
8756   result = (Dali::Radian *)&Dali::ANGLE_120;
8757   jresult = (void *)result;
8758   return jresult;
8759 }
8760
8761
8762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8763   void * jresult ;
8764   Dali::Radian *result = 0 ;
8765
8766   result = (Dali::Radian *)&Dali::ANGLE_90;
8767   jresult = (void *)result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8773   void * jresult ;
8774   Dali::Radian *result = 0 ;
8775
8776   result = (Dali::Radian *)&Dali::ANGLE_60;
8777   jresult = (void *)result;
8778   return jresult;
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8783   void * jresult ;
8784   Dali::Radian *result = 0 ;
8785
8786   result = (Dali::Radian *)&Dali::ANGLE_45;
8787   jresult = (void *)result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8793   void * jresult ;
8794   Dali::Radian *result = 0 ;
8795
8796   result = (Dali::Radian *)&Dali::ANGLE_30;
8797   jresult = (void *)result;
8798   return jresult;
8799 }
8800
8801
8802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8803   void * jresult ;
8804   Dali::Radian *result = 0 ;
8805
8806   result = (Dali::Radian *)&Dali::ANGLE_0;
8807   jresult = (void *)result;
8808   return jresult;
8809 }
8810
8811
8812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8813   unsigned int jresult ;
8814   Dali::Degree *arg1 = 0 ;
8815   Dali::Degree *arg2 = 0 ;
8816   bool result;
8817
8818   arg1 = (Dali::Degree *)jarg1;
8819   if (!arg1) {
8820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8821     return 0;
8822   }
8823   arg2 = (Dali::Degree *)jarg2;
8824   if (!arg2) {
8825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8826     return 0;
8827   }
8828   {
8829     try {
8830       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8831     } catch (std::out_of_range& e) {
8832       {
8833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8834       };
8835     } catch (std::exception& e) {
8836       {
8837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8838       };
8839     } catch (...) {
8840       {
8841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8842       };
8843     }
8844   }
8845   jresult = result;
8846   return jresult;
8847 }
8848
8849
8850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8851   unsigned int jresult ;
8852   Dali::Degree *arg1 = 0 ;
8853   Dali::Degree *arg2 = 0 ;
8854   bool result;
8855
8856   arg1 = (Dali::Degree *)jarg1;
8857   if (!arg1) {
8858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8859     return 0;
8860   }
8861   arg2 = (Dali::Degree *)jarg2;
8862   if (!arg2) {
8863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8864     return 0;
8865   }
8866   {
8867     try {
8868       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8869     } catch (std::out_of_range& e) {
8870       {
8871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8872       };
8873     } catch (std::exception& e) {
8874       {
8875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (...) {
8878       {
8879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8880       };
8881     }
8882   }
8883   jresult = result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8889   void * jresult ;
8890   Dali::Degree arg1 ;
8891   float arg2 ;
8892   float arg3 ;
8893   Dali::Degree *argp1 ;
8894   Dali::Degree result;
8895
8896   argp1 = (Dali::Degree *)jarg1;
8897   if (!argp1) {
8898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8899     return 0;
8900   }
8901   arg1 = *argp1;
8902   arg2 = (float)jarg2;
8903   arg3 = (float)jarg3;
8904   {
8905     try {
8906       result = Dali::Clamp(arg1,arg2,arg3);
8907     } catch (std::out_of_range& e) {
8908       {
8909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (std::exception& e) {
8912       {
8913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8914       };
8915     } catch (...) {
8916       {
8917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8918       };
8919     }
8920   }
8921   jresult = new Dali::Degree((const Dali::Degree &)result);
8922   return jresult;
8923 }
8924
8925
8926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8927   void * jresult ;
8928   Dali::Radian *result = 0 ;
8929
8930   {
8931     try {
8932       result = (Dali::Radian *)new Dali::Radian();
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (...) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8944       };
8945     }
8946   }
8947   jresult = (void *)result;
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8953   void * jresult ;
8954   float arg1 ;
8955   Dali::Radian *result = 0 ;
8956
8957   arg1 = (float)jarg1;
8958   {
8959     try {
8960       result = (Dali::Radian *)new Dali::Radian(arg1);
8961     } catch (std::out_of_range& e) {
8962       {
8963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8964       };
8965     } catch (std::exception& e) {
8966       {
8967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (...) {
8970       {
8971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8972       };
8973     }
8974   }
8975   jresult = (void *)result;
8976   return jresult;
8977 }
8978
8979
8980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8981   void * jresult ;
8982   Dali::Degree arg1 ;
8983   Dali::Degree *argp1 ;
8984   Dali::Radian *result = 0 ;
8985
8986   argp1 = (Dali::Degree *)jarg1;
8987   if (!argp1) {
8988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8989     return 0;
8990   }
8991   arg1 = *argp1;
8992   {
8993     try {
8994       result = (Dali::Radian *)new Dali::Radian(arg1);
8995     } catch (std::out_of_range& e) {
8996       {
8997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8998       };
8999     } catch (std::exception& e) {
9000       {
9001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (...) {
9004       {
9005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9006       };
9007     }
9008   }
9009   jresult = (void *)result;
9010   return jresult;
9011 }
9012
9013
9014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9015   void * jresult ;
9016   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9017   float arg2 ;
9018   Dali::Radian *result = 0 ;
9019
9020   arg1 = (Dali::Radian *)jarg1;
9021   arg2 = (float)jarg2;
9022   {
9023     try {
9024       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9025     } catch (std::out_of_range& e) {
9026       {
9027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9028       };
9029     } catch (std::exception& e) {
9030       {
9031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9032       };
9033     } catch (...) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9036       };
9037     }
9038   }
9039   jresult = (void *)result;
9040   return jresult;
9041 }
9042
9043
9044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9045   void * jresult ;
9046   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9047   Dali::Degree arg2 ;
9048   Dali::Degree *argp2 ;
9049   Dali::Radian *result = 0 ;
9050
9051   arg1 = (Dali::Radian *)jarg1;
9052   argp2 = (Dali::Degree *)jarg2;
9053   if (!argp2) {
9054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9055     return 0;
9056   }
9057   arg2 = *argp2;
9058   {
9059     try {
9060       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9061     } catch (std::out_of_range& e) {
9062       {
9063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9064       };
9065     } catch (std::exception& e) {
9066       {
9067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9068       };
9069     } catch (...) {
9070       {
9071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9072       };
9073     }
9074   }
9075   jresult = (void *)result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9081   float jresult ;
9082   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9083   float result;
9084
9085   arg1 = (Dali::Radian *)jarg1;
9086   {
9087     try {
9088       result = (float)((Dali::Radian const *)arg1)->operator float();
9089     } catch (std::out_of_range& e) {
9090       {
9091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9092       };
9093     } catch (std::exception& e) {
9094       {
9095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9096       };
9097     } catch (...) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9100       };
9101     }
9102   }
9103   jresult = result;
9104   return jresult;
9105 }
9106
9107
9108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9109   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9110   float arg2 ;
9111
9112   arg1 = (Dali::Radian *)jarg1;
9113   arg2 = (float)jarg2;
9114   if (arg1) (arg1)->radian = arg2;
9115 }
9116
9117
9118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9119   float jresult ;
9120   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9121   float result;
9122
9123   arg1 = (Dali::Radian *)jarg1;
9124   result = (float) ((arg1)->radian);
9125   jresult = result;
9126   return jresult;
9127 }
9128
9129
9130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9131   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9132
9133   arg1 = (Dali::Radian *)jarg1;
9134   {
9135     try {
9136       delete arg1;
9137     } catch (std::out_of_range& e) {
9138       {
9139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (std::exception& e) {
9142       {
9143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151 }
9152
9153
9154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9155   unsigned int jresult ;
9156   Dali::Radian arg1 ;
9157   Dali::Radian arg2 ;
9158   Dali::Radian *argp1 ;
9159   Dali::Radian *argp2 ;
9160   bool result;
9161
9162   argp1 = (Dali::Radian *)jarg1;
9163   if (!argp1) {
9164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9165     return 0;
9166   }
9167   arg1 = *argp1;
9168   argp2 = (Dali::Radian *)jarg2;
9169   if (!argp2) {
9170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9171     return 0;
9172   }
9173   arg2 = *argp2;
9174   {
9175     try {
9176       result = (bool)Dali::operator ==(arg1,arg2);
9177     } catch (std::out_of_range& e) {
9178       {
9179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9180       };
9181     } catch (std::exception& e) {
9182       {
9183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9184       };
9185     } catch (...) {
9186       {
9187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9188       };
9189     }
9190   }
9191   jresult = result;
9192   return jresult;
9193 }
9194
9195
9196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9197   unsigned int jresult ;
9198   Dali::Radian arg1 ;
9199   Dali::Radian arg2 ;
9200   Dali::Radian *argp1 ;
9201   Dali::Radian *argp2 ;
9202   bool result;
9203
9204   argp1 = (Dali::Radian *)jarg1;
9205   if (!argp1) {
9206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9207     return 0;
9208   }
9209   arg1 = *argp1;
9210   argp2 = (Dali::Radian *)jarg2;
9211   if (!argp2) {
9212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9213     return 0;
9214   }
9215   arg2 = *argp2;
9216   {
9217     try {
9218       result = (bool)Dali::operator !=(arg1,arg2);
9219     } catch (std::out_of_range& e) {
9220       {
9221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9222       };
9223     } catch (std::exception& e) {
9224       {
9225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9230       };
9231     }
9232   }
9233   jresult = result;
9234   return jresult;
9235 }
9236
9237
9238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9239   unsigned int jresult ;
9240   Dali::Radian arg1 ;
9241   Dali::Degree arg2 ;
9242   Dali::Radian *argp1 ;
9243   Dali::Degree *argp2 ;
9244   bool result;
9245
9246   argp1 = (Dali::Radian *)jarg1;
9247   if (!argp1) {
9248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9249     return 0;
9250   }
9251   arg1 = *argp1;
9252   argp2 = (Dali::Degree *)jarg2;
9253   if (!argp2) {
9254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9255     return 0;
9256   }
9257   arg2 = *argp2;
9258   {
9259     try {
9260       result = (bool)Dali::operator ==(arg1,arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9268       };
9269     } catch (...) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9272       };
9273     }
9274   }
9275   jresult = result;
9276   return jresult;
9277 }
9278
9279
9280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9281   unsigned int jresult ;
9282   Dali::Radian arg1 ;
9283   Dali::Degree arg2 ;
9284   Dali::Radian *argp1 ;
9285   Dali::Degree *argp2 ;
9286   bool result;
9287
9288   argp1 = (Dali::Radian *)jarg1;
9289   if (!argp1) {
9290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9291     return 0;
9292   }
9293   arg1 = *argp1;
9294   argp2 = (Dali::Degree *)jarg2;
9295   if (!argp2) {
9296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9297     return 0;
9298   }
9299   arg2 = *argp2;
9300   {
9301     try {
9302       result = (bool)Dali::operator !=(arg1,arg2);
9303     } catch (std::out_of_range& e) {
9304       {
9305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9306       };
9307     } catch (std::exception& e) {
9308       {
9309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9310       };
9311     } catch (...) {
9312       {
9313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9314       };
9315     }
9316   }
9317   jresult = result;
9318   return jresult;
9319 }
9320
9321
9322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9323   unsigned int jresult ;
9324   Dali::Degree arg1 ;
9325   Dali::Radian arg2 ;
9326   Dali::Degree *argp1 ;
9327   Dali::Radian *argp2 ;
9328   bool result;
9329
9330   argp1 = (Dali::Degree *)jarg1;
9331   if (!argp1) {
9332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9333     return 0;
9334   }
9335   arg1 = *argp1;
9336   argp2 = (Dali::Radian *)jarg2;
9337   if (!argp2) {
9338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9339     return 0;
9340   }
9341   arg2 = *argp2;
9342   {
9343     try {
9344       result = (bool)Dali::operator ==(arg1,arg2);
9345     } catch (std::out_of_range& e) {
9346       {
9347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9348       };
9349     } catch (std::exception& e) {
9350       {
9351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9352       };
9353     } catch (...) {
9354       {
9355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9356       };
9357     }
9358   }
9359   jresult = result;
9360   return jresult;
9361 }
9362
9363
9364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9365   unsigned int jresult ;
9366   Dali::Degree arg1 ;
9367   Dali::Radian arg2 ;
9368   Dali::Degree *argp1 ;
9369   Dali::Radian *argp2 ;
9370   bool result;
9371
9372   argp1 = (Dali::Degree *)jarg1;
9373   if (!argp1) {
9374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9375     return 0;
9376   }
9377   arg1 = *argp1;
9378   argp2 = (Dali::Radian *)jarg2;
9379   if (!argp2) {
9380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9381     return 0;
9382   }
9383   arg2 = *argp2;
9384   {
9385     try {
9386       result = (bool)Dali::operator !=(arg1,arg2);
9387     } catch (std::out_of_range& e) {
9388       {
9389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9390       };
9391     } catch (std::exception& e) {
9392       {
9393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9394       };
9395     } catch (...) {
9396       {
9397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9398       };
9399     }
9400   }
9401   jresult = result;
9402   return jresult;
9403 }
9404
9405
9406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9407   unsigned int jresult ;
9408   Dali::Radian arg1 ;
9409   Dali::Radian arg2 ;
9410   Dali::Radian *argp1 ;
9411   Dali::Radian *argp2 ;
9412   bool result;
9413
9414   argp1 = (Dali::Radian *)jarg1;
9415   if (!argp1) {
9416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9417     return 0;
9418   }
9419   arg1 = *argp1;
9420   argp2 = (Dali::Radian *)jarg2;
9421   if (!argp2) {
9422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9423     return 0;
9424   }
9425   arg2 = *argp2;
9426   {
9427     try {
9428       result = (bool)Dali::operator >(arg1,arg2);
9429     } catch (std::out_of_range& e) {
9430       {
9431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9432       };
9433     } catch (std::exception& e) {
9434       {
9435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9436       };
9437     } catch (...) {
9438       {
9439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9440       };
9441     }
9442   }
9443   jresult = result;
9444   return jresult;
9445 }
9446
9447
9448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9449   unsigned int jresult ;
9450   Dali::Radian arg1 ;
9451   Dali::Degree arg2 ;
9452   Dali::Radian *argp1 ;
9453   Dali::Degree *argp2 ;
9454   bool result;
9455
9456   argp1 = (Dali::Radian *)jarg1;
9457   if (!argp1) {
9458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9459     return 0;
9460   }
9461   arg1 = *argp1;
9462   argp2 = (Dali::Degree *)jarg2;
9463   if (!argp2) {
9464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9465     return 0;
9466   }
9467   arg2 = *argp2;
9468   {
9469     try {
9470       result = (bool)Dali::operator >(arg1,arg2);
9471     } catch (std::out_of_range& e) {
9472       {
9473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9474       };
9475     } catch (std::exception& e) {
9476       {
9477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9478       };
9479     } catch (...) {
9480       {
9481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9482       };
9483     }
9484   }
9485   jresult = result;
9486   return jresult;
9487 }
9488
9489
9490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9491   unsigned int jresult ;
9492   Dali::Degree arg1 ;
9493   Dali::Radian arg2 ;
9494   Dali::Degree *argp1 ;
9495   Dali::Radian *argp2 ;
9496   bool result;
9497
9498   argp1 = (Dali::Degree *)jarg1;
9499   if (!argp1) {
9500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9501     return 0;
9502   }
9503   arg1 = *argp1;
9504   argp2 = (Dali::Radian *)jarg2;
9505   if (!argp2) {
9506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9507     return 0;
9508   }
9509   arg2 = *argp2;
9510   {
9511     try {
9512       result = (bool)Dali::operator >(arg1,arg2);
9513     } catch (std::out_of_range& e) {
9514       {
9515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9516       };
9517     } catch (std::exception& e) {
9518       {
9519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (...) {
9522       {
9523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9524       };
9525     }
9526   }
9527   jresult = result;
9528   return jresult;
9529 }
9530
9531
9532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9533   unsigned int jresult ;
9534   Dali::Radian arg1 ;
9535   Dali::Radian arg2 ;
9536   Dali::Radian *argp1 ;
9537   Dali::Radian *argp2 ;
9538   bool result;
9539
9540   argp1 = (Dali::Radian *)jarg1;
9541   if (!argp1) {
9542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9543     return 0;
9544   }
9545   arg1 = *argp1;
9546   argp2 = (Dali::Radian *)jarg2;
9547   if (!argp2) {
9548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9549     return 0;
9550   }
9551   arg2 = *argp2;
9552   {
9553     try {
9554       result = (bool)Dali::operator <(arg1,arg2);
9555     } catch (std::out_of_range& e) {
9556       {
9557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9558       };
9559     } catch (std::exception& e) {
9560       {
9561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (...) {
9564       {
9565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9566       };
9567     }
9568   }
9569   jresult = result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9575   unsigned int jresult ;
9576   Dali::Radian arg1 ;
9577   Dali::Degree arg2 ;
9578   Dali::Radian *argp1 ;
9579   Dali::Degree *argp2 ;
9580   bool result;
9581
9582   argp1 = (Dali::Radian *)jarg1;
9583   if (!argp1) {
9584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9585     return 0;
9586   }
9587   arg1 = *argp1;
9588   argp2 = (Dali::Degree *)jarg2;
9589   if (!argp2) {
9590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9591     return 0;
9592   }
9593   arg2 = *argp2;
9594   {
9595     try {
9596       result = (bool)Dali::operator <(arg1,arg2);
9597     } catch (std::out_of_range& e) {
9598       {
9599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9600       };
9601     } catch (std::exception& e) {
9602       {
9603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9604       };
9605     } catch (...) {
9606       {
9607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9608       };
9609     }
9610   }
9611   jresult = result;
9612   return jresult;
9613 }
9614
9615
9616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9617   unsigned int jresult ;
9618   Dali::Degree arg1 ;
9619   Dali::Radian arg2 ;
9620   Dali::Degree *argp1 ;
9621   Dali::Radian *argp2 ;
9622   bool result;
9623
9624   argp1 = (Dali::Degree *)jarg1;
9625   if (!argp1) {
9626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9627     return 0;
9628   }
9629   arg1 = *argp1;
9630   argp2 = (Dali::Radian *)jarg2;
9631   if (!argp2) {
9632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9633     return 0;
9634   }
9635   arg2 = *argp2;
9636   {
9637     try {
9638       result = (bool)Dali::operator <(arg1,arg2);
9639     } catch (std::out_of_range& e) {
9640       {
9641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9642       };
9643     } catch (std::exception& e) {
9644       {
9645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9646       };
9647     } catch (...) {
9648       {
9649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9650       };
9651     }
9652   }
9653   jresult = result;
9654   return jresult;
9655 }
9656
9657
9658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9659   void * jresult ;
9660   Dali::Radian arg1 ;
9661   float arg2 ;
9662   Dali::Radian *argp1 ;
9663   Dali::Radian result;
9664
9665   argp1 = (Dali::Radian *)jarg1;
9666   if (!argp1) {
9667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9668     return 0;
9669   }
9670   arg1 = *argp1;
9671   arg2 = (float)jarg2;
9672   {
9673     try {
9674       result = Dali::operator *(arg1,arg2);
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9682       };
9683     } catch (...) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9686       };
9687     }
9688   }
9689   jresult = new Dali::Radian((const Dali::Radian &)result);
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9695   void * jresult ;
9696   Dali::Radian arg1 ;
9697   Dali::Radian *argp1 ;
9698   Dali::Radian result;
9699
9700   argp1 = (Dali::Radian *)jarg1;
9701   if (!argp1) {
9702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9703     return 0;
9704   }
9705   arg1 = *argp1;
9706   {
9707     try {
9708       result = Dali::operator -(arg1);
9709     } catch (std::out_of_range& e) {
9710       {
9711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9712       };
9713     } catch (std::exception& e) {
9714       {
9715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9716       };
9717     } catch (...) {
9718       {
9719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9720       };
9721     }
9722   }
9723   jresult = new Dali::Radian((const Dali::Radian &)result);
9724   return jresult;
9725 }
9726
9727
9728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9729   void * jresult ;
9730   Dali::Radian arg1 ;
9731   float arg2 ;
9732   float arg3 ;
9733   Dali::Radian *argp1 ;
9734   Dali::Radian result;
9735
9736   argp1 = (Dali::Radian *)jarg1;
9737   if (!argp1) {
9738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9739     return 0;
9740   }
9741   arg1 = *argp1;
9742   arg2 = (float)jarg2;
9743   arg3 = (float)jarg3;
9744   {
9745     try {
9746       result = Dali::Clamp(arg1,arg2,arg3);
9747     } catch (std::out_of_range& e) {
9748       {
9749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9750       };
9751     } catch (std::exception& e) {
9752       {
9753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9754       };
9755     } catch (...) {
9756       {
9757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9758       };
9759     }
9760   }
9761   jresult = new Dali::Radian((const Dali::Radian &)result);
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9767   void * jresult ;
9768   Dali::Quaternion *result = 0 ;
9769
9770   {
9771     try {
9772       result = (Dali::Quaternion *)new Dali::Quaternion();
9773     } catch (std::out_of_range& e) {
9774       {
9775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9776       };
9777     } catch (std::exception& e) {
9778       {
9779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9780       };
9781     } catch (...) {
9782       {
9783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9784       };
9785     }
9786   }
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9793   void * jresult ;
9794   Dali::Radian arg1 ;
9795   Dali::Vector3 *arg2 = 0 ;
9796   Dali::Radian *argp1 ;
9797   Dali::Quaternion *result = 0 ;
9798
9799   argp1 = (Dali::Radian *)jarg1;
9800   if (!argp1) {
9801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9802     return 0;
9803   }
9804   arg1 = *argp1;
9805   arg2 = (Dali::Vector3 *)jarg2;
9806   if (!arg2) {
9807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9808     return 0;
9809   }
9810   {
9811     try {
9812       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9813     } catch (std::out_of_range& e) {
9814       {
9815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9816       };
9817     } catch (std::exception& e) {
9818       {
9819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9820       };
9821     } catch (...) {
9822       {
9823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9824       };
9825     }
9826   }
9827   jresult = (void *)result;
9828   return jresult;
9829 }
9830
9831
9832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9833   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9834
9835   arg1 = (Dali::Quaternion *)jarg1;
9836   {
9837     try {
9838       delete arg1;
9839     } catch (std::out_of_range& e) {
9840       {
9841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9842       };
9843     } catch (std::exception& e) {
9844       {
9845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9846       };
9847     } catch (...) {
9848       {
9849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9850       };
9851     }
9852   }
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9857   void * jresult ;
9858   Dali::Quaternion *result = 0 ;
9859
9860   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9861   jresult = (void *)result;
9862   return jresult;
9863 }
9864
9865
9866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9867   unsigned int jresult ;
9868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9869   bool result;
9870
9871   arg1 = (Dali::Quaternion *)jarg1;
9872   {
9873     try {
9874       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9875     } catch (std::out_of_range& e) {
9876       {
9877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (std::exception& e) {
9880       {
9881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (...) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9886       };
9887     }
9888   }
9889   jresult = result;
9890   return jresult;
9891 }
9892
9893
9894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9895   unsigned int jresult ;
9896   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9897   Dali::Vector3 *arg2 = 0 ;
9898   Dali::Radian *arg3 = 0 ;
9899   bool result;
9900
9901   arg1 = (Dali::Quaternion *)jarg1;
9902   arg2 = (Dali::Vector3 *)jarg2;
9903   if (!arg2) {
9904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9905     return 0;
9906   }
9907   arg3 = (Dali::Radian *)jarg3;
9908   if (!arg3) {
9909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9910     return 0;
9911   }
9912   {
9913     try {
9914       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9915     } catch (std::out_of_range& e) {
9916       {
9917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9918       };
9919     } catch (std::exception& e) {
9920       {
9921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (...) {
9924       {
9925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9926       };
9927     }
9928   }
9929   jresult = result;
9930   return jresult;
9931 }
9932
9933
9934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9935   void * jresult ;
9936   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9937   Dali::Quaternion *arg2 = 0 ;
9938   Dali::Quaternion result;
9939
9940   arg1 = (Dali::Quaternion *)jarg1;
9941   arg2 = (Dali::Quaternion *)jarg2;
9942   if (!arg2) {
9943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9944     return 0;
9945   }
9946   {
9947     try {
9948       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9949     } catch (std::out_of_range& e) {
9950       {
9951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9952       };
9953     } catch (std::exception& e) {
9954       {
9955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (...) {
9958       {
9959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9960       };
9961     }
9962   }
9963   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9964   return jresult;
9965 }
9966
9967
9968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9969   void * jresult ;
9970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9971   Dali::Quaternion *arg2 = 0 ;
9972   Dali::Quaternion result;
9973
9974   arg1 = (Dali::Quaternion *)jarg1;
9975   arg2 = (Dali::Quaternion *)jarg2;
9976   if (!arg2) {
9977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9978     return 0;
9979   }
9980   {
9981     try {
9982       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (...) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9994       };
9995     }
9996   }
9997   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10003   void * jresult ;
10004   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10005   Dali::Quaternion *arg2 = 0 ;
10006   Dali::Quaternion result;
10007
10008   arg1 = (Dali::Quaternion *)jarg1;
10009   arg2 = (Dali::Quaternion *)jarg2;
10010   if (!arg2) {
10011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10012     return 0;
10013   }
10014   {
10015     try {
10016       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10017     } catch (std::out_of_range& e) {
10018       {
10019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (std::exception& e) {
10022       {
10023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10024       };
10025     } catch (...) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10028       };
10029     }
10030   }
10031   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10037   void * jresult ;
10038   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10039   Dali::Vector3 *arg2 = 0 ;
10040   Dali::Vector3 result;
10041
10042   arg1 = (Dali::Quaternion *)jarg1;
10043   arg2 = (Dali::Vector3 *)jarg2;
10044   if (!arg2) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10046     return 0;
10047   }
10048   {
10049     try {
10050       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10051     } catch (std::out_of_range& e) {
10052       {
10053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10054       };
10055     } catch (std::exception& e) {
10056       {
10057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (...) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10062       };
10063     }
10064   }
10065   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10066   return jresult;
10067 }
10068
10069
10070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10071   void * jresult ;
10072   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10073   Dali::Quaternion *arg2 = 0 ;
10074   Dali::Quaternion result;
10075
10076   arg1 = (Dali::Quaternion *)jarg1;
10077   arg2 = (Dali::Quaternion *)jarg2;
10078   if (!arg2) {
10079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10080     return 0;
10081   }
10082   {
10083     try {
10084       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (...) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10096       };
10097     }
10098   }
10099   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10100   return jresult;
10101 }
10102
10103
10104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10105   void * jresult ;
10106   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10107   float arg2 ;
10108   Dali::Quaternion result;
10109
10110   arg1 = (Dali::Quaternion *)jarg1;
10111   arg2 = (float)jarg2;
10112   {
10113     try {
10114       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10115     } catch (std::out_of_range& e) {
10116       {
10117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10118       };
10119     } catch (std::exception& e) {
10120       {
10121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10122       };
10123     } catch (...) {
10124       {
10125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10126       };
10127     }
10128   }
10129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10130   return jresult;
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10135   void * jresult ;
10136   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10137   float arg2 ;
10138   Dali::Quaternion result;
10139
10140   arg1 = (Dali::Quaternion *)jarg1;
10141   arg2 = (float)jarg2;
10142   {
10143     try {
10144       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10145     } catch (std::out_of_range& e) {
10146       {
10147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10148       };
10149     } catch (std::exception& e) {
10150       {
10151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10152       };
10153     } catch (...) {
10154       {
10155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10156       };
10157     }
10158   }
10159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10160   return jresult;
10161 }
10162
10163
10164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10165   void * jresult ;
10166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10167   Dali::Quaternion result;
10168
10169   arg1 = (Dali::Quaternion *)jarg1;
10170   {
10171     try {
10172       result = ((Dali::Quaternion const *)arg1)->operator -();
10173     } catch (std::out_of_range& e) {
10174       {
10175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10176       };
10177     } catch (std::exception& e) {
10178       {
10179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10180       };
10181     } catch (...) {
10182       {
10183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10184       };
10185     }
10186   }
10187   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10188   return jresult;
10189 }
10190
10191
10192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10193   void * jresult ;
10194   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10195   Dali::Quaternion *arg2 = 0 ;
10196   Dali::Quaternion *result = 0 ;
10197
10198   arg1 = (Dali::Quaternion *)jarg1;
10199   arg2 = (Dali::Quaternion *)jarg2;
10200   if (!arg2) {
10201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10202     return 0;
10203   }
10204   {
10205     try {
10206       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10207     } catch (std::out_of_range& e) {
10208       {
10209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10210       };
10211     } catch (std::exception& e) {
10212       {
10213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10214       };
10215     } catch (...) {
10216       {
10217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10218       };
10219     }
10220   }
10221   jresult = (void *)result;
10222   return jresult;
10223 }
10224
10225
10226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10227   void * jresult ;
10228   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10229   Dali::Quaternion *arg2 = 0 ;
10230   Dali::Quaternion *result = 0 ;
10231
10232   arg1 = (Dali::Quaternion *)jarg1;
10233   arg2 = (Dali::Quaternion *)jarg2;
10234   if (!arg2) {
10235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10236     return 0;
10237   }
10238   {
10239     try {
10240       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10241     } catch (std::out_of_range& e) {
10242       {
10243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10244       };
10245     } catch (std::exception& e) {
10246       {
10247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10248       };
10249     } catch (...) {
10250       {
10251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10252       };
10253     }
10254   }
10255   jresult = (void *)result;
10256   return jresult;
10257 }
10258
10259
10260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10261   void * jresult ;
10262   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10263   Dali::Quaternion *arg2 = 0 ;
10264   Dali::Quaternion *result = 0 ;
10265
10266   arg1 = (Dali::Quaternion *)jarg1;
10267   arg2 = (Dali::Quaternion *)jarg2;
10268   if (!arg2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10270     return 0;
10271   }
10272   {
10273     try {
10274       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289   jresult = (void *)result;
10290   return jresult;
10291 }
10292
10293
10294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10295   void * jresult ;
10296   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10297   float arg2 ;
10298   Dali::Quaternion *result = 0 ;
10299
10300   arg1 = (Dali::Quaternion *)jarg1;
10301   arg2 = (float)jarg2;
10302   {
10303     try {
10304       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10305     } catch (std::out_of_range& e) {
10306       {
10307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10308       };
10309     } catch (std::exception& e) {
10310       {
10311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10312       };
10313     } catch (...) {
10314       {
10315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10316       };
10317     }
10318   }
10319   jresult = (void *)result;
10320   return jresult;
10321 }
10322
10323
10324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10325   void * jresult ;
10326   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10327   float arg2 ;
10328   Dali::Quaternion *result = 0 ;
10329
10330   arg1 = (Dali::Quaternion *)jarg1;
10331   arg2 = (float)jarg2;
10332   {
10333     try {
10334       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10335     } catch (std::out_of_range& e) {
10336       {
10337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10338       };
10339     } catch (std::exception& e) {
10340       {
10341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10342       };
10343     } catch (...) {
10344       {
10345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10346       };
10347     }
10348   }
10349   jresult = (void *)result;
10350   return jresult;
10351 }
10352
10353
10354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10355   unsigned int jresult ;
10356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10357   Dali::Quaternion *arg2 = 0 ;
10358   bool result;
10359
10360   arg1 = (Dali::Quaternion *)jarg1;
10361   arg2 = (Dali::Quaternion *)jarg2;
10362   if (!arg2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10364     return 0;
10365   }
10366   {
10367     try {
10368       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10369     } catch (std::out_of_range& e) {
10370       {
10371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (std::exception& e) {
10374       {
10375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (...) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10380       };
10381     }
10382   }
10383   jresult = result;
10384   return jresult;
10385 }
10386
10387
10388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10389   unsigned int jresult ;
10390   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10391   Dali::Quaternion *arg2 = 0 ;
10392   bool result;
10393
10394   arg1 = (Dali::Quaternion *)jarg1;
10395   arg2 = (Dali::Quaternion *)jarg2;
10396   if (!arg2) {
10397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10398     return 0;
10399   }
10400   {
10401     try {
10402       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10403     } catch (std::out_of_range& e) {
10404       {
10405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10406       };
10407     } catch (std::exception& e) {
10408       {
10409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10410       };
10411     } catch (...) {
10412       {
10413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10414       };
10415     }
10416   }
10417   jresult = result;
10418   return jresult;
10419 }
10420
10421
10422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10423   float jresult ;
10424   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10425   float result;
10426
10427   arg1 = (Dali::Quaternion *)jarg1;
10428   {
10429     try {
10430       result = (float)((Dali::Quaternion const *)arg1)->Length();
10431     } catch (std::out_of_range& e) {
10432       {
10433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10434       };
10435     } catch (std::exception& e) {
10436       {
10437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10438       };
10439     } catch (...) {
10440       {
10441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10442       };
10443     }
10444   }
10445   jresult = result;
10446   return jresult;
10447 }
10448
10449
10450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10451   float jresult ;
10452   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10453   float result;
10454
10455   arg1 = (Dali::Quaternion *)jarg1;
10456   {
10457     try {
10458       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (...) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10470       };
10471     }
10472   }
10473   jresult = result;
10474   return jresult;
10475 }
10476
10477
10478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10479   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10480
10481   arg1 = (Dali::Quaternion *)jarg1;
10482   {
10483     try {
10484       (arg1)->Normalize();
10485     } catch (std::out_of_range& e) {
10486       {
10487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10488       };
10489     } catch (std::exception& e) {
10490       {
10491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10492       };
10493     } catch (...) {
10494       {
10495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10496       };
10497     }
10498   }
10499 }
10500
10501
10502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10503   void * jresult ;
10504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10505   Dali::Quaternion result;
10506
10507   arg1 = (Dali::Quaternion *)jarg1;
10508   {
10509     try {
10510       result = ((Dali::Quaternion const *)arg1)->Normalized();
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (...) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10522       };
10523     }
10524   }
10525   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10526   return jresult;
10527 }
10528
10529
10530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10531   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10532
10533   arg1 = (Dali::Quaternion *)jarg1;
10534   {
10535     try {
10536       (arg1)->Conjugate();
10537     } catch (std::out_of_range& e) {
10538       {
10539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10540       };
10541     } catch (std::exception& e) {
10542       {
10543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10544       };
10545     } catch (...) {
10546       {
10547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10548       };
10549     }
10550   }
10551 }
10552
10553
10554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10555   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10556
10557   arg1 = (Dali::Quaternion *)jarg1;
10558   {
10559     try {
10560       (arg1)->Invert();
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10568       };
10569     } catch (...) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10572       };
10573     }
10574   }
10575 }
10576
10577
10578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10579   void * jresult ;
10580   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10581   Dali::Quaternion result;
10582
10583   arg1 = (Dali::Quaternion *)jarg1;
10584   {
10585     try {
10586       result = ((Dali::Quaternion const *)arg1)->Log();
10587     } catch (std::out_of_range& e) {
10588       {
10589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10590       };
10591     } catch (std::exception& e) {
10592       {
10593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10594       };
10595     } catch (...) {
10596       {
10597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10598       };
10599     }
10600   }
10601   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10602   return jresult;
10603 }
10604
10605
10606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10607   void * jresult ;
10608   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10609   Dali::Quaternion result;
10610
10611   arg1 = (Dali::Quaternion *)jarg1;
10612   {
10613     try {
10614       result = ((Dali::Quaternion const *)arg1)->Exp();
10615     } catch (std::out_of_range& e) {
10616       {
10617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (std::exception& e) {
10620       {
10621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10622       };
10623     } catch (...) {
10624       {
10625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10626       };
10627     }
10628   }
10629   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10630   return jresult;
10631 }
10632
10633
10634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10635   float jresult ;
10636   Dali::Quaternion *arg1 = 0 ;
10637   Dali::Quaternion *arg2 = 0 ;
10638   float result;
10639
10640   arg1 = (Dali::Quaternion *)jarg1;
10641   if (!arg1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10643     return 0;
10644   }
10645   arg2 = (Dali::Quaternion *)jarg2;
10646   if (!arg2) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10648     return 0;
10649   }
10650   {
10651     try {
10652       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (...) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10664       };
10665     }
10666   }
10667   jresult = result;
10668   return jresult;
10669 }
10670
10671
10672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10673   void * jresult ;
10674   Dali::Quaternion *arg1 = 0 ;
10675   Dali::Quaternion *arg2 = 0 ;
10676   float arg3 ;
10677   Dali::Quaternion result;
10678
10679   arg1 = (Dali::Quaternion *)jarg1;
10680   if (!arg1) {
10681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10682     return 0;
10683   }
10684   arg2 = (Dali::Quaternion *)jarg2;
10685   if (!arg2) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10687     return 0;
10688   }
10689   arg3 = (float)jarg3;
10690   {
10691     try {
10692       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10693     } catch (std::out_of_range& e) {
10694       {
10695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10696       };
10697     } catch (std::exception& e) {
10698       {
10699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10700       };
10701     } catch (...) {
10702       {
10703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10704       };
10705     }
10706   }
10707   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10708   return jresult;
10709 }
10710
10711
10712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10713   void * jresult ;
10714   Dali::Quaternion *arg1 = 0 ;
10715   Dali::Quaternion *arg2 = 0 ;
10716   float arg3 ;
10717   Dali::Quaternion result;
10718
10719   arg1 = (Dali::Quaternion *)jarg1;
10720   if (!arg1) {
10721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10722     return 0;
10723   }
10724   arg2 = (Dali::Quaternion *)jarg2;
10725   if (!arg2) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10727     return 0;
10728   }
10729   arg3 = (float)jarg3;
10730   {
10731     try {
10732       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10733     } catch (std::out_of_range& e) {
10734       {
10735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (std::exception& e) {
10738       {
10739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10740       };
10741     } catch (...) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10744       };
10745     }
10746   }
10747   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10748   return jresult;
10749 }
10750
10751
10752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10753   void * jresult ;
10754   Dali::Quaternion *arg1 = 0 ;
10755   Dali::Quaternion *arg2 = 0 ;
10756   float arg3 ;
10757   Dali::Quaternion result;
10758
10759   arg1 = (Dali::Quaternion *)jarg1;
10760   if (!arg1) {
10761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10762     return 0;
10763   }
10764   arg2 = (Dali::Quaternion *)jarg2;
10765   if (!arg2) {
10766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10767     return 0;
10768   }
10769   arg3 = (float)jarg3;
10770   {
10771     try {
10772       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10773     } catch (std::out_of_range& e) {
10774       {
10775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10776       };
10777     } catch (std::exception& e) {
10778       {
10779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10780       };
10781     } catch (...) {
10782       {
10783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10784       };
10785     }
10786   }
10787   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10788   return jresult;
10789 }
10790
10791
10792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10793   void * jresult ;
10794   Dali::Quaternion *arg1 = 0 ;
10795   Dali::Quaternion *arg2 = 0 ;
10796   Dali::Quaternion *arg3 = 0 ;
10797   Dali::Quaternion *arg4 = 0 ;
10798   float arg5 ;
10799   Dali::Quaternion result;
10800
10801   arg1 = (Dali::Quaternion *)jarg1;
10802   if (!arg1) {
10803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10804     return 0;
10805   }
10806   arg2 = (Dali::Quaternion *)jarg2;
10807   if (!arg2) {
10808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10809     return 0;
10810   }
10811   arg3 = (Dali::Quaternion *)jarg3;
10812   if (!arg3) {
10813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10814     return 0;
10815   }
10816   arg4 = (Dali::Quaternion *)jarg4;
10817   if (!arg4) {
10818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10819     return 0;
10820   }
10821   arg5 = (float)jarg5;
10822   {
10823     try {
10824       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10840   return jresult;
10841 }
10842
10843
10844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10845   float jresult ;
10846   Dali::Quaternion *arg1 = 0 ;
10847   Dali::Quaternion *arg2 = 0 ;
10848   float result;
10849
10850   arg1 = (Dali::Quaternion *)jarg1;
10851   if (!arg1) {
10852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10853     return 0;
10854   }
10855   arg2 = (Dali::Quaternion *)jarg2;
10856   if (!arg2) {
10857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10858     return 0;
10859   }
10860   {
10861     try {
10862       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10863     } catch (std::out_of_range& e) {
10864       {
10865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10866       };
10867     } catch (std::exception& e) {
10868       {
10869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10870       };
10871     } catch (...) {
10872       {
10873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10874       };
10875     }
10876   }
10877   jresult = result;
10878   return jresult;
10879 }
10880
10881
10882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10883   void * jresult ;
10884   Dali::Matrix *result = 0 ;
10885
10886   {
10887     try {
10888       result = (Dali::Matrix *)new Dali::Matrix();
10889     } catch (std::out_of_range& e) {
10890       {
10891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10892       };
10893     } catch (std::exception& e) {
10894       {
10895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10896       };
10897     } catch (...) {
10898       {
10899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10900       };
10901     }
10902   }
10903   jresult = (void *)result;
10904   return jresult;
10905 }
10906
10907
10908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10909   void * jresult ;
10910   bool arg1 ;
10911   Dali::Matrix *result = 0 ;
10912
10913   arg1 = jarg1 ? true : false;
10914   {
10915     try {
10916       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10917     } catch (std::out_of_range& e) {
10918       {
10919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10920       };
10921     } catch (std::exception& e) {
10922       {
10923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10924       };
10925     } catch (...) {
10926       {
10927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10928       };
10929     }
10930   }
10931   jresult = (void *)result;
10932   return jresult;
10933 }
10934
10935
10936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10937   void * jresult ;
10938   float *arg1 = (float *) 0 ;
10939   Dali::Matrix *result = 0 ;
10940
10941   arg1 = jarg1;
10942   {
10943     try {
10944       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (...) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10956       };
10957     }
10958   }
10959   jresult = (void *)result;
10960
10961
10962   return jresult;
10963 }
10964
10965
10966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10967   void * jresult ;
10968   Dali::Quaternion *arg1 = 0 ;
10969   Dali::Matrix *result = 0 ;
10970
10971   arg1 = (Dali::Quaternion *)jarg1;
10972   if (!arg1) {
10973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10974     return 0;
10975   }
10976   {
10977     try {
10978       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10986       };
10987     } catch (...) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10990       };
10991     }
10992   }
10993   jresult = (void *)result;
10994   return jresult;
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10999   void * jresult ;
11000   Dali::Matrix *arg1 = 0 ;
11001   Dali::Matrix *result = 0 ;
11002
11003   arg1 = (Dali::Matrix *)jarg1;
11004   if (!arg1) {
11005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11006     return 0;
11007   }
11008   {
11009     try {
11010       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11011     } catch (std::out_of_range& e) {
11012       {
11013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11014       };
11015     } catch (std::exception& e) {
11016       {
11017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (...) {
11020       {
11021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11022       };
11023     }
11024   }
11025   jresult = (void *)result;
11026   return jresult;
11027 }
11028
11029
11030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11031   void * jresult ;
11032   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11033   Dali::Matrix *arg2 = 0 ;
11034   Dali::Matrix *result = 0 ;
11035
11036   arg1 = (Dali::Matrix *)jarg1;
11037   arg2 = (Dali::Matrix *)jarg2;
11038   if (!arg2) {
11039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11040     return 0;
11041   }
11042   {
11043     try {
11044       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11045     } catch (std::out_of_range& e) {
11046       {
11047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11048       };
11049     } catch (std::exception& e) {
11050       {
11051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11052       };
11053     } catch (...) {
11054       {
11055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11056       };
11057     }
11058   }
11059   jresult = (void *)result;
11060   return jresult;
11061 }
11062
11063
11064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11065   void * jresult ;
11066   Dali::Matrix *result = 0 ;
11067
11068   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11069   jresult = (void *)result;
11070   return jresult;
11071 }
11072
11073
11074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11075   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11076
11077   arg1 = (Dali::Matrix *)jarg1;
11078   {
11079     try {
11080       (arg1)->SetIdentity();
11081     } catch (std::out_of_range& e) {
11082       {
11083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11084       };
11085     } catch (std::exception& e) {
11086       {
11087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11088       };
11089     } catch (...) {
11090       {
11091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11092       };
11093     }
11094   }
11095 }
11096
11097
11098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11099   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11100   Dali::Vector3 *arg2 = 0 ;
11101
11102   arg1 = (Dali::Matrix *)jarg1;
11103   arg2 = (Dali::Vector3 *)jarg2;
11104   if (!arg2) {
11105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11106     return ;
11107   }
11108   {
11109     try {
11110       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11111     } catch (std::out_of_range& e) {
11112       {
11113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11114       };
11115     } catch (std::exception& e) {
11116       {
11117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11118       };
11119     } catch (...) {
11120       {
11121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11122       };
11123     }
11124   }
11125 }
11126
11127
11128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11129   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11130   Dali::Matrix *arg2 = 0 ;
11131
11132   arg1 = (Dali::Matrix *)jarg1;
11133   arg2 = (Dali::Matrix *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11136     return ;
11137   }
11138   {
11139     try {
11140       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11152       };
11153     }
11154   }
11155 }
11156
11157
11158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11159   unsigned int jresult ;
11160   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11161   bool result;
11162
11163   arg1 = (Dali::Matrix *)jarg1;
11164   {
11165     try {
11166       result = (bool)(arg1)->Invert();
11167     } catch (std::out_of_range& e) {
11168       {
11169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11170       };
11171     } catch (std::exception& e) {
11172       {
11173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11174       };
11175     } catch (...) {
11176       {
11177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11178       };
11179     }
11180   }
11181   jresult = result;
11182   return jresult;
11183 }
11184
11185
11186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11187   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11188
11189   arg1 = (Dali::Matrix *)jarg1;
11190   {
11191     try {
11192       (arg1)->Transpose();
11193     } catch (std::out_of_range& e) {
11194       {
11195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11196       };
11197     } catch (std::exception& e) {
11198       {
11199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11200       };
11201     } catch (...) {
11202       {
11203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11204       };
11205     }
11206   }
11207 }
11208
11209
11210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11211   void * jresult ;
11212   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11213   Dali::Vector3 result;
11214
11215   arg1 = (Dali::Matrix *)jarg1;
11216   {
11217     try {
11218       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (...) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11230       };
11231     }
11232   }
11233   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11234   return jresult;
11235 }
11236
11237
11238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11239   void * jresult ;
11240   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11241   Dali::Vector3 result;
11242
11243   arg1 = (Dali::Matrix *)jarg1;
11244   {
11245     try {
11246       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11254       };
11255     } catch (...) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11258       };
11259     }
11260   }
11261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11262   return jresult;
11263 }
11264
11265
11266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11267   void * jresult ;
11268   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11269   Dali::Vector3 result;
11270
11271   arg1 = (Dali::Matrix *)jarg1;
11272   {
11273     try {
11274       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11275     } catch (std::out_of_range& e) {
11276       {
11277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11278       };
11279     } catch (std::exception& e) {
11280       {
11281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11282       };
11283     } catch (...) {
11284       {
11285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11286       };
11287     }
11288   }
11289   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11290   return jresult;
11291 }
11292
11293
11294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11295   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11296   Dali::Vector3 *arg2 = 0 ;
11297
11298   arg1 = (Dali::Matrix *)jarg1;
11299   arg2 = (Dali::Vector3 *)jarg2;
11300   if (!arg2) {
11301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11302     return ;
11303   }
11304   {
11305     try {
11306       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11307     } catch (std::out_of_range& e) {
11308       {
11309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11310       };
11311     } catch (std::exception& e) {
11312       {
11313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11314       };
11315     } catch (...) {
11316       {
11317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11318       };
11319     }
11320   }
11321 }
11322
11323
11324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11325   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11326   Dali::Vector3 *arg2 = 0 ;
11327
11328   arg1 = (Dali::Matrix *)jarg1;
11329   arg2 = (Dali::Vector3 *)jarg2;
11330   if (!arg2) {
11331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11332     return ;
11333   }
11334   {
11335     try {
11336       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11337     } catch (std::out_of_range& e) {
11338       {
11339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11340       };
11341     } catch (std::exception& e) {
11342       {
11343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11344       };
11345     } catch (...) {
11346       {
11347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11348       };
11349     }
11350   }
11351 }
11352
11353
11354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11356   Dali::Vector3 *arg2 = 0 ;
11357
11358   arg1 = (Dali::Matrix *)jarg1;
11359   arg2 = (Dali::Vector3 *)jarg2;
11360   if (!arg2) {
11361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11362     return ;
11363   }
11364   {
11365     try {
11366       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11367     } catch (std::out_of_range& e) {
11368       {
11369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11370       };
11371     } catch (std::exception& e) {
11372       {
11373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11378       };
11379     }
11380   }
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11385   void * jresult ;
11386   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11387   Dali::Vector4 *result = 0 ;
11388
11389   arg1 = (Dali::Matrix *)jarg1;
11390   {
11391     try {
11392       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11393     } catch (std::out_of_range& e) {
11394       {
11395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11396       };
11397     } catch (std::exception& e) {
11398       {
11399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11404       };
11405     }
11406   }
11407   jresult = (void *)result;
11408   return jresult;
11409 }
11410
11411
11412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11413   void * jresult ;
11414   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11415   Dali::Vector3 *result = 0 ;
11416
11417   arg1 = (Dali::Matrix *)jarg1;
11418   {
11419     try {
11420       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11421     } catch (std::out_of_range& e) {
11422       {
11423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11424       };
11425     } catch (std::exception& e) {
11426       {
11427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11428       };
11429     } catch (...) {
11430       {
11431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11432       };
11433     }
11434   }
11435   jresult = (void *)result;
11436   return jresult;
11437 }
11438
11439
11440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11441   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11442   Dali::Vector4 *arg2 = 0 ;
11443
11444   arg1 = (Dali::Matrix *)jarg1;
11445   arg2 = (Dali::Vector4 *)jarg2;
11446   if (!arg2) {
11447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11448     return ;
11449   }
11450   {
11451     try {
11452       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11453     } catch (std::out_of_range& e) {
11454       {
11455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11456       };
11457     } catch (std::exception& e) {
11458       {
11459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11460       };
11461     } catch (...) {
11462       {
11463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11464       };
11465     }
11466   }
11467 }
11468
11469
11470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11471   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11472   Dali::Vector3 *arg2 = 0 ;
11473
11474   arg1 = (Dali::Matrix *)jarg1;
11475   arg2 = (Dali::Vector3 *)jarg2;
11476   if (!arg2) {
11477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11478     return ;
11479   }
11480   {
11481     try {
11482       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11483     } catch (std::out_of_range& e) {
11484       {
11485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11486       };
11487     } catch (std::exception& e) {
11488       {
11489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11490       };
11491     } catch (...) {
11492       {
11493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11494       };
11495     }
11496   }
11497 }
11498
11499
11500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11501   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11502
11503   arg1 = (Dali::Matrix *)jarg1;
11504   {
11505     try {
11506       (arg1)->OrthoNormalize();
11507     } catch (std::out_of_range& e) {
11508       {
11509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11510       };
11511     } catch (std::exception& e) {
11512       {
11513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11514       };
11515     } catch (...) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11518       };
11519     }
11520   }
11521 }
11522
11523
11524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11525   void * jresult ;
11526   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11527   float *result = 0 ;
11528
11529   arg1 = (Dali::Matrix *)jarg1;
11530   {
11531     try {
11532       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11533     } catch (std::out_of_range& e) {
11534       {
11535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11536       };
11537     } catch (std::exception& e) {
11538       {
11539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11540       };
11541     } catch (...) {
11542       {
11543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11544       };
11545     }
11546   }
11547   jresult = (void *)result;
11548   return jresult;
11549 }
11550
11551
11552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11553   Dali::Matrix *arg1 = 0 ;
11554   Dali::Matrix *arg2 = 0 ;
11555   Dali::Matrix *arg3 = 0 ;
11556
11557   arg1 = (Dali::Matrix *)jarg1;
11558   if (!arg1) {
11559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11560     return ;
11561   }
11562   arg2 = (Dali::Matrix *)jarg2;
11563   if (!arg2) {
11564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11565     return ;
11566   }
11567   arg3 = (Dali::Matrix *)jarg3;
11568   if (!arg3) {
11569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11570     return ;
11571   }
11572   {
11573     try {
11574       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11575     } catch (std::out_of_range& e) {
11576       {
11577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11578       };
11579     } catch (std::exception& e) {
11580       {
11581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11582       };
11583     } catch (...) {
11584       {
11585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11586       };
11587     }
11588   }
11589 }
11590
11591
11592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11593   Dali::Matrix *arg1 = 0 ;
11594   Dali::Matrix *arg2 = 0 ;
11595   Dali::Quaternion *arg3 = 0 ;
11596
11597   arg1 = (Dali::Matrix *)jarg1;
11598   if (!arg1) {
11599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11600     return ;
11601   }
11602   arg2 = (Dali::Matrix *)jarg2;
11603   if (!arg2) {
11604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11605     return ;
11606   }
11607   arg3 = (Dali::Quaternion *)jarg3;
11608   if (!arg3) {
11609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11610     return ;
11611   }
11612   {
11613     try {
11614       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11615     } catch (std::out_of_range& e) {
11616       {
11617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11618       };
11619     } catch (std::exception& e) {
11620       {
11621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11622       };
11623     } catch (...) {
11624       {
11625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11626       };
11627     }
11628   }
11629 }
11630
11631
11632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11633   void * jresult ;
11634   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11635   Dali::Vector4 *arg2 = 0 ;
11636   Dali::Vector4 result;
11637
11638   arg1 = (Dali::Matrix *)jarg1;
11639   arg2 = (Dali::Vector4 *)jarg2;
11640   if (!arg2) {
11641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11642     return 0;
11643   }
11644   {
11645     try {
11646       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11647     } catch (std::out_of_range& e) {
11648       {
11649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11650       };
11651     } catch (std::exception& e) {
11652       {
11653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11654       };
11655     } catch (...) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11658       };
11659     }
11660   }
11661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11662   return jresult;
11663 }
11664
11665
11666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11667   unsigned int jresult ;
11668   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11669   Dali::Matrix *arg2 = 0 ;
11670   bool result;
11671
11672   arg1 = (Dali::Matrix *)jarg1;
11673   arg2 = (Dali::Matrix *)jarg2;
11674   if (!arg2) {
11675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11676     return 0;
11677   }
11678   {
11679     try {
11680       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11688       };
11689     } catch (...) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11692       };
11693     }
11694   }
11695   jresult = result;
11696   return jresult;
11697 }
11698
11699
11700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11701   unsigned int jresult ;
11702   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11703   Dali::Matrix *arg2 = 0 ;
11704   bool result;
11705
11706   arg1 = (Dali::Matrix *)jarg1;
11707   arg2 = (Dali::Matrix *)jarg2;
11708   if (!arg2) {
11709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11710     return 0;
11711   }
11712   {
11713     try {
11714       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11715     } catch (std::out_of_range& e) {
11716       {
11717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11718       };
11719     } catch (std::exception& e) {
11720       {
11721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11722       };
11723     } catch (...) {
11724       {
11725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11726       };
11727     }
11728   }
11729   jresult = result;
11730   return jresult;
11731 }
11732
11733
11734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11736   Dali::Vector3 *arg2 = 0 ;
11737   Dali::Quaternion *arg3 = 0 ;
11738   Dali::Vector3 *arg4 = 0 ;
11739
11740   arg1 = (Dali::Matrix *)jarg1;
11741   arg2 = (Dali::Vector3 *)jarg2;
11742   if (!arg2) {
11743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11744     return ;
11745   }
11746   arg3 = (Dali::Quaternion *)jarg3;
11747   if (!arg3) {
11748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11749     return ;
11750   }
11751   arg4 = (Dali::Vector3 *)jarg4;
11752   if (!arg4) {
11753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11754     return ;
11755   }
11756   {
11757     try {
11758       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11759     } catch (std::out_of_range& e) {
11760       {
11761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11762       };
11763     } catch (std::exception& e) {
11764       {
11765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11766       };
11767     } catch (...) {
11768       {
11769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11770       };
11771     }
11772   }
11773 }
11774
11775
11776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11777   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11778   Dali::Vector3 *arg2 = 0 ;
11779   Dali::Quaternion *arg3 = 0 ;
11780   Dali::Vector3 *arg4 = 0 ;
11781
11782   arg1 = (Dali::Matrix *)jarg1;
11783   arg2 = (Dali::Vector3 *)jarg2;
11784   if (!arg2) {
11785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11786     return ;
11787   }
11788   arg3 = (Dali::Quaternion *)jarg3;
11789   if (!arg3) {
11790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11791     return ;
11792   }
11793   arg4 = (Dali::Vector3 *)jarg4;
11794   if (!arg4) {
11795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11796     return ;
11797   }
11798   {
11799     try {
11800       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11801     } catch (std::out_of_range& e) {
11802       {
11803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11804       };
11805     } catch (std::exception& e) {
11806       {
11807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11808       };
11809     } catch (...) {
11810       {
11811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11812       };
11813     }
11814   }
11815 }
11816
11817
11818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11819   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11820   Dali::Vector3 *arg2 = 0 ;
11821   Dali::Vector3 *arg3 = 0 ;
11822   Dali::Vector3 *arg4 = 0 ;
11823   Dali::Vector3 *arg5 = 0 ;
11824
11825   arg1 = (Dali::Matrix *)jarg1;
11826   arg2 = (Dali::Vector3 *)jarg2;
11827   if (!arg2) {
11828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11829     return ;
11830   }
11831   arg3 = (Dali::Vector3 *)jarg3;
11832   if (!arg3) {
11833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11834     return ;
11835   }
11836   arg4 = (Dali::Vector3 *)jarg4;
11837   if (!arg4) {
11838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11839     return ;
11840   }
11841   arg5 = (Dali::Vector3 *)jarg5;
11842   if (!arg5) {
11843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11844     return ;
11845   }
11846   {
11847     try {
11848       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11849     } catch (std::out_of_range& e) {
11850       {
11851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11852       };
11853     } catch (std::exception& e) {
11854       {
11855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11860       };
11861     }
11862   }
11863 }
11864
11865
11866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11867   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11868   Dali::Vector3 *arg2 = 0 ;
11869   Dali::Quaternion *arg3 = 0 ;
11870   Dali::Vector3 *arg4 = 0 ;
11871
11872   arg1 = (Dali::Matrix *)jarg1;
11873   arg2 = (Dali::Vector3 *)jarg2;
11874   if (!arg2) {
11875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11876     return ;
11877   }
11878   arg3 = (Dali::Quaternion *)jarg3;
11879   if (!arg3) {
11880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11881     return ;
11882   }
11883   arg4 = (Dali::Vector3 *)jarg4;
11884   if (!arg4) {
11885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11886     return ;
11887   }
11888   {
11889     try {
11890       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11891     } catch (std::out_of_range& e) {
11892       {
11893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11894       };
11895     } catch (std::exception& e) {
11896       {
11897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11898       };
11899     } catch (...) {
11900       {
11901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11902       };
11903     }
11904   }
11905 }
11906
11907
11908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11909   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11910
11911   arg1 = (Dali::Matrix *)jarg1;
11912   {
11913     try {
11914       delete arg1;
11915     } catch (std::out_of_range& e) {
11916       {
11917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11918       };
11919     } catch (std::exception& e) {
11920       {
11921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11922       };
11923     } catch (...) {
11924       {
11925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11926       };
11927     }
11928   }
11929 }
11930
11931
11932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11933   void * jresult ;
11934   Dali::Matrix3 *result = 0 ;
11935
11936   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11937   jresult = (void *)result;
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11943   void * jresult ;
11944   Dali::Matrix3 *result = 0 ;
11945
11946   {
11947     try {
11948       result = (Dali::Matrix3 *)new Dali::Matrix3();
11949     } catch (std::out_of_range& e) {
11950       {
11951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11952       };
11953     } catch (std::exception& e) {
11954       {
11955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11956       };
11957     } catch (...) {
11958       {
11959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11960       };
11961     }
11962   }
11963   jresult = (void *)result;
11964   return jresult;
11965 }
11966
11967
11968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11969   void * jresult ;
11970   Dali::Matrix3 *arg1 = 0 ;
11971   Dali::Matrix3 *result = 0 ;
11972
11973   arg1 = (Dali::Matrix3 *)jarg1;
11974   if (!arg1) {
11975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11976     return 0;
11977   }
11978   {
11979     try {
11980       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11981     } catch (std::out_of_range& e) {
11982       {
11983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11984       };
11985     } catch (std::exception& e) {
11986       {
11987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11988       };
11989     } catch (...) {
11990       {
11991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11992       };
11993     }
11994   }
11995   jresult = (void *)result;
11996   return jresult;
11997 }
11998
11999
12000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12001   void * jresult ;
12002   Dali::Matrix *arg1 = 0 ;
12003   Dali::Matrix3 *result = 0 ;
12004
12005   arg1 = (Dali::Matrix *)jarg1;
12006   if (!arg1) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027   jresult = (void *)result;
12028   return jresult;
12029 }
12030
12031
12032 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) {
12033   void * jresult ;
12034   float arg1 ;
12035   float arg2 ;
12036   float arg3 ;
12037   float arg4 ;
12038   float arg5 ;
12039   float arg6 ;
12040   float arg7 ;
12041   float arg8 ;
12042   float arg9 ;
12043   Dali::Matrix3 *result = 0 ;
12044
12045   arg1 = (float)jarg1;
12046   arg2 = (float)jarg2;
12047   arg3 = (float)jarg3;
12048   arg4 = (float)jarg4;
12049   arg5 = (float)jarg5;
12050   arg6 = (float)jarg6;
12051   arg7 = (float)jarg7;
12052   arg8 = (float)jarg8;
12053   arg9 = (float)jarg9;
12054   {
12055     try {
12056       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12057     } catch (std::out_of_range& e) {
12058       {
12059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12060       };
12061     } catch (std::exception& e) {
12062       {
12063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12064       };
12065     } catch (...) {
12066       {
12067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12068       };
12069     }
12070   }
12071   jresult = (void *)result;
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12077   void * jresult ;
12078   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12079   Dali::Matrix3 *arg2 = 0 ;
12080   Dali::Matrix3 *result = 0 ;
12081
12082   arg1 = (Dali::Matrix3 *)jarg1;
12083   arg2 = (Dali::Matrix3 *)jarg2;
12084   if (!arg2) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12086     return 0;
12087   }
12088   {
12089     try {
12090       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12091     } catch (std::out_of_range& e) {
12092       {
12093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12094       };
12095     } catch (std::exception& e) {
12096       {
12097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12098       };
12099     } catch (...) {
12100       {
12101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12102       };
12103     }
12104   }
12105   jresult = (void *)result;
12106   return jresult;
12107 }
12108
12109
12110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12111   void * jresult ;
12112   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12113   Dali::Matrix *arg2 = 0 ;
12114   Dali::Matrix3 *result = 0 ;
12115
12116   arg1 = (Dali::Matrix3 *)jarg1;
12117   arg2 = (Dali::Matrix *)jarg2;
12118   if (!arg2) {
12119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12120     return 0;
12121   }
12122   {
12123     try {
12124       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12125     } catch (std::out_of_range& e) {
12126       {
12127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12128       };
12129     } catch (std::exception& e) {
12130       {
12131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12132       };
12133     } catch (...) {
12134       {
12135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12136       };
12137     }
12138   }
12139   jresult = (void *)result;
12140   return jresult;
12141 }
12142
12143
12144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12145   unsigned int jresult ;
12146   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12147   Dali::Matrix3 *arg2 = 0 ;
12148   bool result;
12149
12150   arg1 = (Dali::Matrix3 *)jarg1;
12151   arg2 = (Dali::Matrix3 *)jarg2;
12152   if (!arg2) {
12153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12154     return 0;
12155   }
12156   {
12157     try {
12158       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12159     } catch (std::out_of_range& e) {
12160       {
12161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (std::exception& e) {
12164       {
12165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173   jresult = result;
12174   return jresult;
12175 }
12176
12177
12178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12179   unsigned int jresult ;
12180   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12181   Dali::Matrix3 *arg2 = 0 ;
12182   bool result;
12183
12184   arg1 = (Dali::Matrix3 *)jarg1;
12185   arg2 = (Dali::Matrix3 *)jarg2;
12186   if (!arg2) {
12187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12188     return 0;
12189   }
12190   {
12191     try {
12192       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12193     } catch (std::out_of_range& e) {
12194       {
12195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (std::exception& e) {
12198       {
12199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207   jresult = result;
12208   return jresult;
12209 }
12210
12211
12212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12213   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12214
12215   arg1 = (Dali::Matrix3 *)jarg1;
12216   {
12217     try {
12218       delete arg1;
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12226       };
12227     } catch (...) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12230       };
12231     }
12232   }
12233 }
12234
12235
12236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12237   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12238
12239   arg1 = (Dali::Matrix3 *)jarg1;
12240   {
12241     try {
12242       (arg1)->SetIdentity();
12243     } catch (std::out_of_range& e) {
12244       {
12245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12246       };
12247     } catch (std::exception& e) {
12248       {
12249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12250       };
12251     } catch (...) {
12252       {
12253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12254       };
12255     }
12256   }
12257 }
12258
12259
12260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12261   void * jresult ;
12262   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12263   float *result = 0 ;
12264
12265   arg1 = (Dali::Matrix3 *)jarg1;
12266   {
12267     try {
12268       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12269     } catch (std::out_of_range& e) {
12270       {
12271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12272       };
12273     } catch (std::exception& e) {
12274       {
12275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12276       };
12277     } catch (...) {
12278       {
12279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12280       };
12281     }
12282   }
12283   jresult = (void *)result;
12284   return jresult;
12285 }
12286
12287
12288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12289   unsigned int jresult ;
12290   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12291   bool result;
12292
12293   arg1 = (Dali::Matrix3 *)jarg1;
12294   {
12295     try {
12296       result = (bool)(arg1)->Invert();
12297     } catch (std::out_of_range& e) {
12298       {
12299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12300       };
12301     } catch (std::exception& e) {
12302       {
12303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12304       };
12305     } catch (...) {
12306       {
12307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12308       };
12309     }
12310   }
12311   jresult = result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12317   unsigned int jresult ;
12318   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12319   bool result;
12320
12321   arg1 = (Dali::Matrix3 *)jarg1;
12322   {
12323     try {
12324       result = (bool)(arg1)->Transpose();
12325     } catch (std::out_of_range& e) {
12326       {
12327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (std::exception& e) {
12330       {
12331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (...) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12336       };
12337     }
12338   }
12339   jresult = result;
12340   return jresult;
12341 }
12342
12343
12344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12345   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12346   float arg2 ;
12347
12348   arg1 = (Dali::Matrix3 *)jarg1;
12349   arg2 = (float)jarg2;
12350   {
12351     try {
12352       (arg1)->Scale(arg2);
12353     } catch (std::out_of_range& e) {
12354       {
12355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12356       };
12357     } catch (std::exception& e) {
12358       {
12359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12360       };
12361     } catch (...) {
12362       {
12363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12364       };
12365     }
12366   }
12367 }
12368
12369
12370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12371   float jresult ;
12372   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12373   float result;
12374
12375   arg1 = (Dali::Matrix3 *)jarg1;
12376   {
12377     try {
12378       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12379     } catch (std::out_of_range& e) {
12380       {
12381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12382       };
12383     } catch (std::exception& e) {
12384       {
12385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12386       };
12387     } catch (...) {
12388       {
12389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12390       };
12391     }
12392   }
12393   jresult = result;
12394   return jresult;
12395 }
12396
12397
12398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12399   unsigned int jresult ;
12400   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12401   bool result;
12402
12403   arg1 = (Dali::Matrix3 *)jarg1;
12404   {
12405     try {
12406       result = (bool)(arg1)->ScaledInverseTranspose();
12407     } catch (std::out_of_range& e) {
12408       {
12409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12410       };
12411     } catch (std::exception& e) {
12412       {
12413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12414       };
12415     } catch (...) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12418       };
12419     }
12420   }
12421   jresult = result;
12422   return jresult;
12423 }
12424
12425
12426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12427   Dali::Matrix3 *arg1 = 0 ;
12428   Dali::Matrix3 *arg2 = 0 ;
12429   Dali::Matrix3 *arg3 = 0 ;
12430
12431   arg1 = (Dali::Matrix3 *)jarg1;
12432   if (!arg1) {
12433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12434     return ;
12435   }
12436   arg2 = (Dali::Matrix3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12439     return ;
12440   }
12441   arg3 = (Dali::Matrix3 *)jarg3;
12442   if (!arg3) {
12443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12444     return ;
12445   }
12446   {
12447     try {
12448       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12449     } catch (std::out_of_range& e) {
12450       {
12451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12452       };
12453     } catch (std::exception& e) {
12454       {
12455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12456       };
12457     } catch (...) {
12458       {
12459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12460       };
12461     }
12462   }
12463 }
12464
12465
12466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12467   float jresult ;
12468   float arg1 ;
12469   float arg2 ;
12470   float result;
12471
12472   arg1 = (float)jarg1;
12473   arg2 = (float)jarg2;
12474   {
12475     try {
12476       result = (float)Dali::Random::Range(arg1,arg2);
12477     } catch (std::out_of_range& e) {
12478       {
12479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12480       };
12481     } catch (std::exception& e) {
12482       {
12483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12484       };
12485     } catch (...) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12488       };
12489     }
12490   }
12491   jresult = result;
12492   return jresult;
12493 }
12494
12495
12496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12497   void * jresult ;
12498   Dali::Vector4 result;
12499
12500   {
12501     try {
12502       result = Dali::Random::Axis();
12503     } catch (std::out_of_range& e) {
12504       {
12505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12506       };
12507     } catch (std::exception& e) {
12508       {
12509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12510       };
12511     } catch (...) {
12512       {
12513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12514       };
12515     }
12516   }
12517   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12523   void * jresult ;
12524   Dali::AngleAxis *result = 0 ;
12525
12526   {
12527     try {
12528       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12529     } catch (std::out_of_range& e) {
12530       {
12531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (std::exception& e) {
12534       {
12535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12536       };
12537     } catch (...) {
12538       {
12539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12540       };
12541     }
12542   }
12543   jresult = (void *)result;
12544   return jresult;
12545 }
12546
12547
12548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12549   void * jresult ;
12550   Dali::Radian arg1 ;
12551   Dali::Vector3 *arg2 = 0 ;
12552   Dali::Radian *argp1 ;
12553   Dali::AngleAxis *result = 0 ;
12554
12555   argp1 = (Dali::Radian *)jarg1;
12556   if (!argp1) {
12557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12558     return 0;
12559   }
12560   arg1 = *argp1;
12561   arg2 = (Dali::Vector3 *)jarg2;
12562   if (!arg2) {
12563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12564     return 0;
12565   }
12566   {
12567     try {
12568       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12569     } catch (std::out_of_range& e) {
12570       {
12571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12572       };
12573     } catch (std::exception& e) {
12574       {
12575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12576       };
12577     } catch (...) {
12578       {
12579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12580       };
12581     }
12582   }
12583   jresult = (void *)result;
12584   return jresult;
12585 }
12586
12587
12588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12589   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12590   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12591
12592   arg1 = (Dali::AngleAxis *)jarg1;
12593   arg2 = (Dali::Radian *)jarg2;
12594   if (arg1) (arg1)->angle = *arg2;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12599   void * jresult ;
12600   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12601   Dali::Radian *result = 0 ;
12602
12603   arg1 = (Dali::AngleAxis *)jarg1;
12604   result = (Dali::Radian *)& ((arg1)->angle);
12605   jresult = (void *)result;
12606   return jresult;
12607 }
12608
12609
12610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12611   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12612   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12613
12614   arg1 = (Dali::AngleAxis *)jarg1;
12615   arg2 = (Dali::Vector3 *)jarg2;
12616   if (arg1) (arg1)->axis = *arg2;
12617 }
12618
12619
12620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12621   void * jresult ;
12622   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12623   Dali::Vector3 *result = 0 ;
12624
12625   arg1 = (Dali::AngleAxis *)jarg1;
12626   result = (Dali::Vector3 *)& ((arg1)->axis);
12627   jresult = (void *)result;
12628   return jresult;
12629 }
12630
12631
12632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12633   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12634
12635   arg1 = (Dali::AngleAxis *)jarg1;
12636   {
12637     try {
12638       delete arg1;
12639     } catch (std::out_of_range& e) {
12640       {
12641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12642       };
12643     } catch (std::exception& e) {
12644       {
12645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12650       };
12651     }
12652   }
12653 }
12654
12655
12656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12657   unsigned int jresult ;
12658   Dali::AngleAxis *arg1 = 0 ;
12659   Dali::AngleAxis *arg2 = 0 ;
12660   bool result;
12661
12662   arg1 = (Dali::AngleAxis *)jarg1;
12663   if (!arg1) {
12664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12665     return 0;
12666   }
12667   arg2 = (Dali::AngleAxis *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12670     return 0;
12671   }
12672   {
12673     try {
12674       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12682       };
12683     } catch (...) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12686       };
12687     }
12688   }
12689   jresult = result;
12690   return jresult;
12691 }
12692
12693
12694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12695   unsigned int jresult ;
12696   unsigned int arg1 ;
12697   unsigned int result;
12698
12699   arg1 = (unsigned int)jarg1;
12700   {
12701     try {
12702       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12703     } catch (std::out_of_range& e) {
12704       {
12705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12706       };
12707     } catch (std::exception& e) {
12708       {
12709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12710       };
12711     } catch (...) {
12712       {
12713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12714       };
12715     }
12716   }
12717   jresult = result;
12718   return jresult;
12719 }
12720
12721
12722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12723   unsigned int jresult ;
12724   unsigned int arg1 ;
12725   bool result;
12726
12727   arg1 = (unsigned int)jarg1;
12728   {
12729     try {
12730       result = (bool)Dali::IsPowerOfTwo(arg1);
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12738       };
12739     } catch (...) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12742       };
12743     }
12744   }
12745   jresult = result;
12746   return jresult;
12747 }
12748
12749
12750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12751   float jresult ;
12752   float arg1 ;
12753   float arg2 ;
12754   float result;
12755
12756   arg1 = (float)jarg1;
12757   arg2 = (float)jarg2;
12758   {
12759     try {
12760       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12761     } catch (std::out_of_range& e) {
12762       {
12763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12764       };
12765     } catch (std::exception& e) {
12766       {
12767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12768       };
12769     } catch (...) {
12770       {
12771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12772       };
12773     }
12774   }
12775   jresult = result;
12776   return jresult;
12777 }
12778
12779
12780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12781   unsigned int jresult ;
12782   float arg1 ;
12783   bool result;
12784
12785   arg1 = (float)jarg1;
12786   {
12787     try {
12788       result = (bool)Dali::EqualsZero(arg1);
12789     } catch (std::out_of_range& e) {
12790       {
12791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12792       };
12793     } catch (std::exception& e) {
12794       {
12795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12796       };
12797     } catch (...) {
12798       {
12799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12800       };
12801     }
12802   }
12803   jresult = result;
12804   return jresult;
12805 }
12806
12807
12808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12809   unsigned int jresult ;
12810   float arg1 ;
12811   float arg2 ;
12812   bool result;
12813
12814   arg1 = (float)jarg1;
12815   arg2 = (float)jarg2;
12816   {
12817     try {
12818       result = (bool)Dali::Equals(arg1,arg2);
12819     } catch (std::out_of_range& e) {
12820       {
12821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12822       };
12823     } catch (std::exception& e) {
12824       {
12825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12826       };
12827     } catch (...) {
12828       {
12829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12830       };
12831     }
12832   }
12833   jresult = result;
12834   return jresult;
12835 }
12836
12837
12838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12839   unsigned int jresult ;
12840   float arg1 ;
12841   float arg2 ;
12842   float arg3 ;
12843   bool result;
12844
12845   arg1 = (float)jarg1;
12846   arg2 = (float)jarg2;
12847   arg3 = (float)jarg3;
12848   {
12849     try {
12850       result = (bool)Dali::Equals(arg1,arg2,arg3);
12851     } catch (std::out_of_range& e) {
12852       {
12853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12854       };
12855     } catch (std::exception& e) {
12856       {
12857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12858       };
12859     } catch (...) {
12860       {
12861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12862       };
12863     }
12864   }
12865   jresult = result;
12866   return jresult;
12867 }
12868
12869
12870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12871   float jresult ;
12872   float arg1 ;
12873   int arg2 ;
12874   float result;
12875
12876   arg1 = (float)jarg1;
12877   arg2 = (int)jarg2;
12878   {
12879     try {
12880       result = (float)Dali::Round(arg1,arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12888       };
12889     } catch (...) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12892       };
12893     }
12894   }
12895   jresult = result;
12896   return jresult;
12897 }
12898
12899
12900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12901   float jresult ;
12902   float arg1 ;
12903   float arg2 ;
12904   float arg3 ;
12905   float result;
12906
12907   arg1 = (float)jarg1;
12908   arg2 = (float)jarg2;
12909   arg3 = (float)jarg3;
12910   {
12911     try {
12912       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12913     } catch (std::out_of_range& e) {
12914       {
12915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12916       };
12917     } catch (std::exception& e) {
12918       {
12919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12924       };
12925     }
12926   }
12927   jresult = result;
12928   return jresult;
12929 }
12930
12931
12932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12933   float jresult ;
12934   float arg1 ;
12935   float arg2 ;
12936   float arg3 ;
12937   float arg4 ;
12938   float result;
12939
12940   arg1 = (float)jarg1;
12941   arg2 = (float)jarg2;
12942   arg3 = (float)jarg3;
12943   arg4 = (float)jarg4;
12944   {
12945     try {
12946       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12947     } catch (std::out_of_range& e) {
12948       {
12949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (std::exception& e) {
12952       {
12953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961   jresult = result;
12962   return jresult;
12963 }
12964
12965
12966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12967   int jresult ;
12968   int result;
12969
12970   result = (int)(int)Dali::Property::INVALID_INDEX;
12971   jresult = result;
12972   return jresult;
12973 }
12974
12975
12976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12977   int jresult ;
12978   int result;
12979
12980   result = (int)(int)Dali::Property::INVALID_KEY;
12981   jresult = result;
12982   return jresult;
12983 }
12984
12985
12986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12987   int jresult ;
12988   int result;
12989
12990   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12991   jresult = result;
12992   return jresult;
12993 }
12994
12995
12996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12997   void * jresult ;
12998   Dali::Handle *arg1 = 0 ;
12999   Dali::Property::Index arg2 ;
13000   Dali::Property *result = 0 ;
13001
13002   arg1 = (Dali::Handle *)jarg1;
13003   if (!arg1) {
13004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13005     return 0;
13006   }
13007   arg2 = (Dali::Property::Index)jarg2;
13008   {
13009     try {
13010       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13011     } catch (std::out_of_range& e) {
13012       {
13013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13014       };
13015     } catch (std::exception& e) {
13016       {
13017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13018       };
13019     } catch (...) {
13020       {
13021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13022       };
13023     }
13024   }
13025   jresult = (void *)result;
13026   return jresult;
13027 }
13028
13029
13030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13031   void * jresult ;
13032   Dali::Handle *arg1 = 0 ;
13033   Dali::Property::Index arg2 ;
13034   int arg3 ;
13035   Dali::Property *result = 0 ;
13036
13037   arg1 = (Dali::Handle *)jarg1;
13038   if (!arg1) {
13039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13040     return 0;
13041   }
13042   arg2 = (Dali::Property::Index)jarg2;
13043   arg3 = (int)jarg3;
13044   {
13045     try {
13046       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13047     } catch (std::out_of_range& e) {
13048       {
13049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13050       };
13051     } catch (std::exception& e) {
13052       {
13053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13054       };
13055     } catch (...) {
13056       {
13057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13058       };
13059     }
13060   }
13061   jresult = (void *)result;
13062   return jresult;
13063 }
13064
13065
13066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13067   void * jresult ;
13068   Dali::Handle *arg1 = 0 ;
13069   std::string *arg2 = 0 ;
13070   Dali::Property *result = 0 ;
13071
13072   arg1 = (Dali::Handle *)jarg1;
13073   if (!arg1) {
13074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13075     return 0;
13076   }
13077   if (!jarg2) {
13078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13079     return 0;
13080   }
13081   std::string arg2_str(jarg2);
13082   arg2 = &arg2_str;
13083   {
13084     try {
13085       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13086     } catch (std::out_of_range& e) {
13087       {
13088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13089       };
13090     } catch (std::exception& e) {
13091       {
13092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13093       };
13094     } catch (...) {
13095       {
13096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13097       };
13098     }
13099   }
13100   jresult = (void *)result;
13101
13102   //argout typemap for const std::string&
13103
13104   return jresult;
13105 }
13106
13107
13108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13109   void * jresult ;
13110   Dali::Handle *arg1 = 0 ;
13111   std::string *arg2 = 0 ;
13112   int arg3 ;
13113   Dali::Property *result = 0 ;
13114
13115   arg1 = (Dali::Handle *)jarg1;
13116   if (!arg1) {
13117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13118     return 0;
13119   }
13120   if (!jarg2) {
13121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13122     return 0;
13123   }
13124   std::string arg2_str(jarg2);
13125   arg2 = &arg2_str;
13126   arg3 = (int)jarg3;
13127   {
13128     try {
13129       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13130     } catch (std::out_of_range& e) {
13131       {
13132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13133       };
13134     } catch (std::exception& e) {
13135       {
13136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13137       };
13138     } catch (...) {
13139       {
13140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13141       };
13142     }
13143   }
13144   jresult = (void *)result;
13145
13146   //argout typemap for const std::string&
13147
13148   return jresult;
13149 }
13150
13151
13152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13153   Dali::Property *arg1 = (Dali::Property *) 0 ;
13154
13155   arg1 = (Dali::Property *)jarg1;
13156   {
13157     try {
13158       delete arg1;
13159     } catch (std::out_of_range& e) {
13160       {
13161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13162       };
13163     } catch (std::exception& e) {
13164       {
13165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13166       };
13167     } catch (...) {
13168       {
13169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13170       };
13171     }
13172   }
13173 }
13174
13175
13176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13177   Dali::Property *arg1 = (Dali::Property *) 0 ;
13178   Dali::Handle *arg2 = 0 ;
13179
13180   arg1 = (Dali::Property *)jarg1;
13181   arg2 = (Dali::Handle *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13184     return ;
13185   }
13186   if (arg1) (arg1)->object = *arg2;
13187 }
13188
13189
13190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13191   void * jresult ;
13192   Dali::Property *arg1 = (Dali::Property *) 0 ;
13193   Dali::Handle *result = 0 ;
13194
13195   arg1 = (Dali::Property *)jarg1;
13196   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13197   jresult = (void *)result;
13198   return jresult;
13199 }
13200
13201
13202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13203   Dali::Property *arg1 = (Dali::Property *) 0 ;
13204   Dali::Property::Index arg2 ;
13205
13206   arg1 = (Dali::Property *)jarg1;
13207   arg2 = (Dali::Property::Index)jarg2;
13208   if (arg1) (arg1)->propertyIndex = arg2;
13209 }
13210
13211
13212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13213   int jresult ;
13214   Dali::Property *arg1 = (Dali::Property *) 0 ;
13215   Dali::Property::Index result;
13216
13217   arg1 = (Dali::Property *)jarg1;
13218   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13219   jresult = result;
13220   return jresult;
13221 }
13222
13223
13224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13225   Dali::Property *arg1 = (Dali::Property *) 0 ;
13226   int arg2 ;
13227
13228   arg1 = (Dali::Property *)jarg1;
13229   arg2 = (int)jarg2;
13230   if (arg1) (arg1)->componentIndex = arg2;
13231 }
13232
13233
13234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13235   int jresult ;
13236   Dali::Property *arg1 = (Dali::Property *) 0 ;
13237   int result;
13238
13239   arg1 = (Dali::Property *)jarg1;
13240   result = (int) ((arg1)->componentIndex);
13241   jresult = result;
13242   return jresult;
13243 }
13244
13245
13246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13247   void * jresult ;
13248   Dali::Property::Array *result = 0 ;
13249
13250   {
13251     try {
13252       result = (Dali::Property::Array *)new Dali::Property::Array();
13253     } catch (std::out_of_range& e) {
13254       {
13255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13256       };
13257     } catch (std::exception& e) {
13258       {
13259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13260       };
13261     } catch (...) {
13262       {
13263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13264       };
13265     }
13266   }
13267   jresult = (void *)result;
13268   return jresult;
13269 }
13270
13271
13272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13273   void * jresult ;
13274   Dali::Property::Array *arg1 = 0 ;
13275   Dali::Property::Array *result = 0 ;
13276
13277   arg1 = (Dali::Property::Array *)jarg1;
13278   if (!arg1) {
13279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13280     return 0;
13281   }
13282   {
13283     try {
13284       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13285     } catch (std::out_of_range& e) {
13286       {
13287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13288       };
13289     } catch (std::exception& e) {
13290       {
13291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13292       };
13293     } catch (...) {
13294       {
13295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13296       };
13297     }
13298   }
13299   jresult = (void *)result;
13300   return jresult;
13301 }
13302
13303
13304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13305   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13306
13307   arg1 = (Dali::Property::Array *)jarg1;
13308   {
13309     try {
13310       delete arg1;
13311     } catch (std::out_of_range& e) {
13312       {
13313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13314       };
13315     } catch (std::exception& e) {
13316       {
13317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13318       };
13319     } catch (...) {
13320       {
13321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13322       };
13323     }
13324   }
13325 }
13326
13327
13328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13329   unsigned long jresult ;
13330   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13331   Dali::Property::Array::SizeType result;
13332
13333   arg1 = (Dali::Property::Array *)jarg1;
13334   {
13335     try {
13336       result = ((Dali::Property::Array const *)arg1)->Size();
13337     } catch (std::out_of_range& e) {
13338       {
13339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13340       };
13341     } catch (std::exception& e) {
13342       {
13343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13344       };
13345     } catch (...) {
13346       {
13347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13348       };
13349     }
13350   }
13351   jresult = (unsigned long)result;
13352   return jresult;
13353 }
13354
13355
13356 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13357   unsigned long jresult ;
13358   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13359   Dali::Property::Array::SizeType result;
13360
13361   arg1 = (Dali::Property::Array *)jarg1;
13362   {
13363     try {
13364       result = ((Dali::Property::Array const *)arg1)->Count();
13365     } catch (std::out_of_range& e) {
13366       {
13367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13368       };
13369     } catch (std::exception& e) {
13370       {
13371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13372       };
13373     } catch (...) {
13374       {
13375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13376       };
13377     }
13378   }
13379   jresult = (unsigned long)result;
13380   return jresult;
13381 }
13382
13383
13384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13385   unsigned int jresult ;
13386   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13387   bool result;
13388
13389   arg1 = (Dali::Property::Array *)jarg1;
13390   {
13391     try {
13392       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13393     } catch (std::out_of_range& e) {
13394       {
13395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13396       };
13397     } catch (std::exception& e) {
13398       {
13399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13400       };
13401     } catch (...) {
13402       {
13403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13404       };
13405     }
13406   }
13407   jresult = result;
13408   return jresult;
13409 }
13410
13411
13412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13413   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13414
13415   arg1 = (Dali::Property::Array *)jarg1;
13416   {
13417     try {
13418       (arg1)->Clear();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13426       };
13427     } catch (...) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13430       };
13431     }
13432   }
13433 }
13434
13435
13436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13437   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13438   Dali::Property::Array::SizeType arg2 ;
13439
13440   arg1 = (Dali::Property::Array *)jarg1;
13441   arg2 = (Dali::Property::Array::SizeType)jarg2;
13442   {
13443     try {
13444       (arg1)->Reserve(arg2);
13445     } catch (std::out_of_range& e) {
13446       {
13447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13448       };
13449     } catch (std::exception& e) {
13450       {
13451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13452       };
13453     } catch (...) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13456       };
13457     }
13458   }
13459 }
13460
13461
13462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13463   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13464   Dali::Property::Array::SizeType arg2 ;
13465
13466   arg1 = (Dali::Property::Array *)jarg1;
13467   arg2 = (Dali::Property::Array::SizeType)jarg2;
13468   {
13469     try {
13470       (arg1)->Resize(arg2);
13471     } catch (std::out_of_range& e) {
13472       {
13473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13474       };
13475     } catch (std::exception& e) {
13476       {
13477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13478       };
13479     } catch (...) {
13480       {
13481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13482       };
13483     }
13484   }
13485 }
13486
13487
13488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13489   unsigned long jresult ;
13490   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13491   Dali::Property::Array::SizeType result;
13492
13493   arg1 = (Dali::Property::Array *)jarg1;
13494   {
13495     try {
13496       result = (arg1)->Capacity();
13497     } catch (std::out_of_range& e) {
13498       {
13499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13500       };
13501     } catch (std::exception& e) {
13502       {
13503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13504       };
13505     } catch (...) {
13506       {
13507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13508       };
13509     }
13510   }
13511   jresult = (unsigned long)result;
13512   return jresult;
13513 }
13514
13515
13516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13517   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13518   Dali::Property::Value *arg2 = 0 ;
13519
13520   arg1 = (Dali::Property::Array *)jarg1;
13521   arg2 = (Dali::Property::Value *)jarg2;
13522   if (!arg2) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13524     return ;
13525   }
13526   {
13527     try {
13528       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13536       };
13537     } catch (...) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13540       };
13541     }
13542   }
13543 }
13544
13545
13546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13547   void * jresult ;
13548   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13549   Dali::Property::Value *arg2 = 0 ;
13550   Dali::Property::Array *result = 0 ;
13551
13552   arg1 = (Dali::Property::Array *)jarg1;
13553   arg2 = (Dali::Property::Value *)jarg2;
13554   if (!arg2) {
13555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13556     return 0;
13557   }
13558   {
13559     try {
13560       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13561     } catch (std::out_of_range& e) {
13562       {
13563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13564       };
13565     } catch (std::exception& e) {
13566       {
13567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13568       };
13569     } catch (...) {
13570       {
13571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13572       };
13573     }
13574   }
13575   jresult = (void *)result;
13576   return jresult;
13577 }
13578
13579
13580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13581   void * jresult ;
13582   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13583   Dali::Property::Array::SizeType arg2 ;
13584   Dali::Property::Value *result = 0 ;
13585
13586   arg1 = (Dali::Property::Array *)jarg1;
13587   arg2 = (Dali::Property::Array::SizeType)jarg2;
13588   {
13589     try {
13590       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13591     } catch (std::out_of_range& e) {
13592       {
13593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13594       };
13595     } catch (std::exception& e) {
13596       {
13597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13598       };
13599     } catch (...) {
13600       {
13601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13602       };
13603     }
13604   }
13605   jresult = (void *)result;
13606   return jresult;
13607 }
13608
13609
13610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13611   void * jresult ;
13612   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13613   Dali::Property::Array::SizeType arg2 ;
13614   Dali::Property::Value *result = 0 ;
13615
13616   arg1 = (Dali::Property::Array *)jarg1;
13617   arg2 = (Dali::Property::Array::SizeType)jarg2;
13618   {
13619     try {
13620       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13621     } catch (std::out_of_range& e) {
13622       {
13623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13624       };
13625     } catch (std::exception& e) {
13626       {
13627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13628       };
13629     } catch (...) {
13630       {
13631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13632       };
13633     }
13634   }
13635   jresult = (void *)result;
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13641   void * jresult ;
13642   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13643   Dali::Property::Array *arg2 = 0 ;
13644   Dali::Property::Array *result = 0 ;
13645
13646   arg1 = (Dali::Property::Array *)jarg1;
13647   arg2 = (Dali::Property::Array *)jarg2;
13648   if (!arg2) {
13649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13650     return 0;
13651   }
13652   {
13653     try {
13654       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13655     } catch (std::out_of_range& e) {
13656       {
13657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (std::exception& e) {
13660       {
13661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669   jresult = (void *)result;
13670   return jresult;
13671 }
13672
13673
13674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13675   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13676   enum Dali::Property::Key::Type arg2 ;
13677
13678   arg1 = (Dali::Property::Key *)jarg1;
13679   arg2 = (enum Dali::Property::Key::Type)jarg2;
13680   if (arg1) (arg1)->type = arg2;
13681 }
13682
13683
13684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13685   int jresult ;
13686   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13687   enum Dali::Property::Key::Type result;
13688
13689   arg1 = (Dali::Property::Key *)jarg1;
13690   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13691   jresult = (int)result;
13692   return jresult;
13693 }
13694
13695
13696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13697   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13698   Dali::Property::Index arg2 ;
13699
13700   arg1 = (Dali::Property::Key *)jarg1;
13701   arg2 = (Dali::Property::Index)jarg2;
13702   if (arg1) (arg1)->indexKey = arg2;
13703 }
13704
13705
13706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13707   int jresult ;
13708   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13709   Dali::Property::Index result;
13710
13711   arg1 = (Dali::Property::Key *)jarg1;
13712   result = (Dali::Property::Index) ((arg1)->indexKey);
13713   jresult = result;
13714   return jresult;
13715 }
13716
13717
13718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13719   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13720   std::string *arg2 = 0 ;
13721
13722   arg1 = (Dali::Property::Key *)jarg1;
13723   if (!jarg2) {
13724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13725     return ;
13726   }
13727   std::string arg2_str(jarg2);
13728   arg2 = &arg2_str;
13729   if (arg1) (arg1)->stringKey = *arg2;
13730
13731   //argout typemap for const std::string&
13732
13733 }
13734
13735
13736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13737   char * jresult ;
13738   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13739   std::string *result = 0 ;
13740
13741   arg1 = (Dali::Property::Key *)jarg1;
13742   result = (std::string *) & ((arg1)->stringKey);
13743   jresult = SWIG_csharp_string_callback(result->c_str());
13744   return jresult;
13745 }
13746
13747
13748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13749   void * jresult ;
13750   std::string *arg1 = 0 ;
13751   Dali::Property::Key *result = 0 ;
13752
13753   if (!jarg1) {
13754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13755     return 0;
13756   }
13757   std::string arg1_str(jarg1);
13758   arg1 = &arg1_str;
13759   {
13760     try {
13761       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13762     } catch (std::out_of_range& e) {
13763       {
13764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13765       };
13766     } catch (std::exception& e) {
13767       {
13768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13769       };
13770     } catch (...) {
13771       {
13772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13773       };
13774     }
13775   }
13776   jresult = (void *)result;
13777
13778   //argout typemap for const std::string&
13779
13780   return jresult;
13781 }
13782
13783
13784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13785   void * jresult ;
13786   Dali::Property::Index arg1 ;
13787   Dali::Property::Key *result = 0 ;
13788
13789   arg1 = (Dali::Property::Index)jarg1;
13790   {
13791     try {
13792       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13793     } catch (std::out_of_range& e) {
13794       {
13795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13796       };
13797     } catch (std::exception& e) {
13798       {
13799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13800       };
13801     } catch (...) {
13802       {
13803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13804       };
13805     }
13806   }
13807   jresult = (void *)result;
13808   return jresult;
13809 }
13810
13811
13812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13813   unsigned int jresult ;
13814   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13815   std::string *arg2 = 0 ;
13816   bool result;
13817
13818   arg1 = (Dali::Property::Key *)jarg1;
13819   if (!jarg2) {
13820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13821     return 0;
13822   }
13823   std::string arg2_str(jarg2);
13824   arg2 = &arg2_str;
13825   {
13826     try {
13827       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13828     } catch (std::out_of_range& e) {
13829       {
13830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13831       };
13832     } catch (std::exception& e) {
13833       {
13834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13835       };
13836     } catch (...) {
13837       {
13838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13839       };
13840     }
13841   }
13842   jresult = result;
13843
13844   //argout typemap for const std::string&
13845
13846   return jresult;
13847 }
13848
13849
13850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13851   unsigned int jresult ;
13852   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13853   Dali::Property::Index arg2 ;
13854   bool result;
13855
13856   arg1 = (Dali::Property::Key *)jarg1;
13857   arg2 = (Dali::Property::Index)jarg2;
13858   {
13859     try {
13860       result = (bool)(arg1)->operator ==(arg2);
13861     } catch (std::out_of_range& e) {
13862       {
13863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13864       };
13865     } catch (std::exception& e) {
13866       {
13867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13868       };
13869     } catch (...) {
13870       {
13871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13872       };
13873     }
13874   }
13875   jresult = result;
13876   return jresult;
13877 }
13878
13879
13880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13881   unsigned int jresult ;
13882   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13883   Dali::Property::Key *arg2 = 0 ;
13884   bool result;
13885
13886   arg1 = (Dali::Property::Key *)jarg1;
13887   arg2 = (Dali::Property::Key *)jarg2;
13888   if (!arg2) {
13889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13890     return 0;
13891   }
13892   {
13893     try {
13894       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13895     } catch (std::out_of_range& e) {
13896       {
13897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13898       };
13899     } catch (std::exception& e) {
13900       {
13901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13902       };
13903     } catch (...) {
13904       {
13905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13906       };
13907     }
13908   }
13909   jresult = result;
13910   return jresult;
13911 }
13912
13913
13914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13915   unsigned int jresult ;
13916   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13917   std::string *arg2 = 0 ;
13918   bool result;
13919
13920   arg1 = (Dali::Property::Key *)jarg1;
13921   if (!jarg2) {
13922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13923     return 0;
13924   }
13925   std::string arg2_str(jarg2);
13926   arg2 = &arg2_str;
13927   {
13928     try {
13929       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13930     } catch (std::out_of_range& e) {
13931       {
13932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13933       };
13934     } catch (std::exception& e) {
13935       {
13936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13937       };
13938     } catch (...) {
13939       {
13940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13941       };
13942     }
13943   }
13944   jresult = result;
13945
13946   //argout typemap for const std::string&
13947
13948   return jresult;
13949 }
13950
13951
13952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13953   unsigned int jresult ;
13954   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13955   Dali::Property::Index arg2 ;
13956   bool result;
13957
13958   arg1 = (Dali::Property::Key *)jarg1;
13959   arg2 = (Dali::Property::Index)jarg2;
13960   {
13961     try {
13962       result = (bool)(arg1)->operator !=(arg2);
13963     } catch (std::out_of_range& e) {
13964       {
13965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13966       };
13967     } catch (std::exception& e) {
13968       {
13969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13970       };
13971     } catch (...) {
13972       {
13973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13974       };
13975     }
13976   }
13977   jresult = result;
13978   return jresult;
13979 }
13980
13981
13982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13983   unsigned int jresult ;
13984   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13985   Dali::Property::Key *arg2 = 0 ;
13986   bool result;
13987
13988   arg1 = (Dali::Property::Key *)jarg1;
13989   arg2 = (Dali::Property::Key *)jarg2;
13990   if (!arg2) {
13991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13992     return 0;
13993   }
13994   {
13995     try {
13996       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13997     } catch (std::out_of_range& e) {
13998       {
13999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14000       };
14001     } catch (std::exception& e) {
14002       {
14003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14004       };
14005     } catch (...) {
14006       {
14007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14008       };
14009     }
14010   }
14011   jresult = result;
14012   return jresult;
14013 }
14014
14015
14016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14017   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14018
14019   arg1 = (Dali::Property::Key *)jarg1;
14020   {
14021     try {
14022       delete arg1;
14023     } catch (std::out_of_range& e) {
14024       {
14025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14026       };
14027     } catch (std::exception& e) {
14028       {
14029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14030       };
14031     } catch (...) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14034       };
14035     }
14036   }
14037 }
14038
14039
14040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14041   void * jresult ;
14042   Dali::Property::Map *result = 0 ;
14043
14044   {
14045     try {
14046       result = (Dali::Property::Map *)new Dali::Property::Map();
14047     } catch (std::out_of_range& e) {
14048       {
14049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14050       };
14051     } catch (std::exception& e) {
14052       {
14053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14054       };
14055     } catch (...) {
14056       {
14057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14058       };
14059     }
14060   }
14061   jresult = (void *)result;
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14067   void * jresult ;
14068   Dali::Property::Map *arg1 = 0 ;
14069   Dali::Property::Map *result = 0 ;
14070
14071   arg1 = (Dali::Property::Map *)jarg1;
14072   if (!arg1) {
14073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14074     return 0;
14075   }
14076   {
14077     try {
14078       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14079     } catch (std::out_of_range& e) {
14080       {
14081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14082       };
14083     } catch (std::exception& e) {
14084       {
14085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14086       };
14087     } catch (...) {
14088       {
14089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14090       };
14091     }
14092   }
14093   jresult = (void *)result;
14094   return jresult;
14095 }
14096
14097
14098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14099   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14100
14101   arg1 = (Dali::Property::Map *)jarg1;
14102   {
14103     try {
14104       delete arg1;
14105     } catch (std::out_of_range& e) {
14106       {
14107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14108       };
14109     } catch (std::exception& e) {
14110       {
14111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14112       };
14113     } catch (...) {
14114       {
14115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14116       };
14117     }
14118   }
14119 }
14120
14121
14122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14123   unsigned long jresult ;
14124   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14125   Dali::Property::Map::SizeType result;
14126
14127   arg1 = (Dali::Property::Map *)jarg1;
14128   {
14129     try {
14130       result = ((Dali::Property::Map const *)arg1)->Count();
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (...) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14142       };
14143     }
14144   }
14145   jresult = (unsigned long)result;
14146   return jresult;
14147 }
14148
14149
14150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14151   unsigned int jresult ;
14152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14153   bool result;
14154
14155   arg1 = (Dali::Property::Map *)jarg1;
14156   {
14157     try {
14158       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14159     } catch (std::out_of_range& e) {
14160       {
14161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14162       };
14163     } catch (std::exception& e) {
14164       {
14165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14166       };
14167     } catch (...) {
14168       {
14169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14170       };
14171     }
14172   }
14173   jresult = result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14179   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14180   char *arg2 = (char *) 0 ;
14181   Dali::Property::Value *arg3 = 0 ;
14182
14183   arg1 = (Dali::Property::Map *)jarg1;
14184   arg2 = (char *)jarg2;
14185   arg3 = (Dali::Property::Value *)jarg3;
14186   if (!arg3) {
14187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14188     return ;
14189   }
14190   {
14191     try {
14192       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14193     } catch (std::out_of_range& e) {
14194       {
14195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14196       };
14197     } catch (std::exception& e) {
14198       {
14199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14200       };
14201     } catch (...) {
14202       {
14203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14204       };
14205     }
14206   }
14207 }
14208
14209
14210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14211   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14212   Dali::Property::Index arg2 ;
14213   Dali::Property::Value *arg3 = 0 ;
14214
14215   arg1 = (Dali::Property::Map *)jarg1;
14216   arg2 = (Dali::Property::Index)jarg2;
14217   arg3 = (Dali::Property::Value *)jarg3;
14218   if (!arg3) {
14219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14220     return ;
14221   }
14222   {
14223     try {
14224       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14225     } catch (std::out_of_range& e) {
14226       {
14227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14228       };
14229     } catch (std::exception& e) {
14230       {
14231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14232       };
14233     } catch (...) {
14234       {
14235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14236       };
14237     }
14238   }
14239 }
14240
14241
14242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14243   void * jresult ;
14244   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14245   char *arg2 = (char *) 0 ;
14246   Dali::Property::Value *arg3 = 0 ;
14247   Dali::Property::Map *result = 0 ;
14248
14249   arg1 = (Dali::Property::Map *)jarg1;
14250   arg2 = (char *)jarg2;
14251   arg3 = (Dali::Property::Value *)jarg3;
14252   if (!arg3) {
14253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14254     return 0;
14255   }
14256   {
14257     try {
14258       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14259     } catch (std::out_of_range& e) {
14260       {
14261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14262       };
14263     } catch (std::exception& e) {
14264       {
14265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14266       };
14267     } catch (...) {
14268       {
14269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14270       };
14271     }
14272   }
14273   jresult = (void *)result;
14274   return jresult;
14275 }
14276
14277
14278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14279   void * jresult ;
14280   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14281   Dali::Property::Index arg2 ;
14282   Dali::Property::Value *arg3 = 0 ;
14283   Dali::Property::Map *result = 0 ;
14284
14285   arg1 = (Dali::Property::Map *)jarg1;
14286   arg2 = (Dali::Property::Index)jarg2;
14287   arg3 = (Dali::Property::Value *)jarg3;
14288   if (!arg3) {
14289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14290     return 0;
14291   }
14292   {
14293     try {
14294       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14295     } catch (std::out_of_range& e) {
14296       {
14297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14298       };
14299     } catch (std::exception& e) {
14300       {
14301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14302       };
14303     } catch (...) {
14304       {
14305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14306       };
14307     }
14308   }
14309   jresult = (void *)result;
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14315   void * jresult ;
14316   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14317   Dali::Property::Map::SizeType arg2 ;
14318   Dali::Property::Value *result = 0 ;
14319
14320   arg1 = (Dali::Property::Map *)jarg1;
14321   arg2 = (Dali::Property::Map::SizeType)jarg2;
14322   {
14323     try {
14324       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14325     } catch (std::out_of_range& e) {
14326       {
14327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (std::exception& e) {
14330       {
14331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339   jresult = (void *)result;
14340   return jresult;
14341 }
14342
14343
14344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14345   char * jresult ;
14346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14347   Dali::Property::Map::SizeType arg2 ;
14348   std::string *result = 0 ;
14349
14350   arg1 = (Dali::Property::Map *)jarg1;
14351   arg2 = (Dali::Property::Map::SizeType)jarg2;
14352   {
14353     try {
14354       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14355     } catch (std::out_of_range& e) {
14356       {
14357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (std::exception& e) {
14360       {
14361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369   jresult = SWIG_csharp_string_callback(result->c_str());
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14375   void * jresult ;
14376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14377   Dali::Property::Map::SizeType arg2 ;
14378   SwigValueWrapper< Dali::Property::Key > result;
14379
14380   arg1 = (Dali::Property::Map *)jarg1;
14381   arg2 = (Dali::Property::Map::SizeType)jarg2;
14382   {
14383     try {
14384       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14405   void * jresult ;
14406   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14407   Dali::Property::Map::SizeType arg2 ;
14408   StringValuePair *result = 0 ;
14409
14410   arg1 = (Dali::Property::Map *)jarg1;
14411   arg2 = (Dali::Property::Map::SizeType)jarg2;
14412   {
14413     try {
14414       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429   jresult = (void *)result;
14430   return jresult;
14431 }
14432
14433
14434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14435   void * jresult ;
14436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14437   char *arg2 = (char *) 0 ;
14438   Dali::Property::Value *result = 0 ;
14439
14440   arg1 = (Dali::Property::Map *)jarg1;
14441   arg2 = (char *)jarg2;
14442   {
14443     try {
14444       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14445     } catch (std::out_of_range& e) {
14446       {
14447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14448       };
14449     } catch (std::exception& e) {
14450       {
14451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14452       };
14453     } catch (...) {
14454       {
14455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14456       };
14457     }
14458   }
14459   jresult = (void *)result;
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14465   void * jresult ;
14466   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14467   Dali::Property::Index arg2 ;
14468   Dali::Property::Value *result = 0 ;
14469
14470   arg1 = (Dali::Property::Map *)jarg1;
14471   arg2 = (Dali::Property::Index)jarg2;
14472   {
14473     try {
14474       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (...) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14486       };
14487     }
14488   }
14489   jresult = (void *)result;
14490   return jresult;
14491 }
14492
14493
14494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14495   void * jresult ;
14496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14497   Dali::Property::Index arg2 ;
14498   std::string *arg3 = 0 ;
14499   Dali::Property::Value *result = 0 ;
14500
14501   arg1 = (Dali::Property::Map *)jarg1;
14502   arg2 = (Dali::Property::Index)jarg2;
14503   if (!jarg3) {
14504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14505     return 0;
14506   }
14507   std::string arg3_str(jarg3);
14508   arg3 = &arg3_str;
14509   {
14510     try {
14511       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14512     } catch (std::out_of_range& e) {
14513       {
14514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (std::exception& e) {
14517       {
14518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14519       };
14520     } catch (...) {
14521       {
14522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14523       };
14524     }
14525   }
14526   jresult = (void *)result;
14527
14528   //argout typemap for const std::string&
14529
14530   return jresult;
14531 }
14532
14533
14534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14535   void * jresult ;
14536   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14537   std::string *arg2 = 0 ;
14538   Dali::Property::Type arg3 ;
14539   Dali::Property::Value *result = 0 ;
14540
14541   arg1 = (Dali::Property::Map *)jarg1;
14542   if (!jarg2) {
14543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14544     return 0;
14545   }
14546   std::string arg2_str(jarg2);
14547   arg2 = &arg2_str;
14548   arg3 = (Dali::Property::Type)jarg3;
14549   {
14550     try {
14551       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14552     } catch (std::out_of_range& e) {
14553       {
14554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14555       };
14556     } catch (std::exception& e) {
14557       {
14558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14559       };
14560     } catch (...) {
14561       {
14562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14563       };
14564     }
14565   }
14566   jresult = (void *)result;
14567
14568   //argout typemap for const std::string&
14569
14570   return jresult;
14571 }
14572
14573
14574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14575   void * jresult ;
14576   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14577   Dali::Property::Index arg2 ;
14578   Dali::Property::Type arg3 ;
14579   Dali::Property::Value *result = 0 ;
14580
14581   arg1 = (Dali::Property::Map *)jarg1;
14582   arg2 = (Dali::Property::Index)jarg2;
14583   arg3 = (Dali::Property::Type)jarg3;
14584   {
14585     try {
14586       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14587     } catch (std::out_of_range& e) {
14588       {
14589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14590       };
14591     } catch (std::exception& e) {
14592       {
14593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14594       };
14595     } catch (...) {
14596       {
14597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14598       };
14599     }
14600   }
14601   jresult = (void *)result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14608
14609   arg1 = (Dali::Property::Map *)jarg1;
14610   {
14611     try {
14612       (arg1)->Clear();
14613     } catch (std::out_of_range& e) {
14614       {
14615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14616       };
14617     } catch (std::exception& e) {
14618       {
14619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14620       };
14621     } catch (...) {
14622       {
14623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14624       };
14625     }
14626   }
14627 }
14628
14629
14630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14631   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14632   Dali::Property::Map *arg2 = 0 ;
14633
14634   arg1 = (Dali::Property::Map *)jarg1;
14635   arg2 = (Dali::Property::Map *)jarg2;
14636   if (!arg2) {
14637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14638     return ;
14639   }
14640   {
14641     try {
14642       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14643     } catch (std::out_of_range& e) {
14644       {
14645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14646       };
14647     } catch (std::exception& e) {
14648       {
14649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14650       };
14651     } catch (...) {
14652       {
14653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14654       };
14655     }
14656   }
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14661   void * jresult ;
14662   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14663   std::string *arg2 = 0 ;
14664   Dali::Property::Value *result = 0 ;
14665
14666   arg1 = (Dali::Property::Map *)jarg1;
14667   if (!jarg2) {
14668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14669     return 0;
14670   }
14671   std::string arg2_str(jarg2);
14672   arg2 = &arg2_str;
14673   {
14674     try {
14675       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14676     } catch (std::out_of_range& e) {
14677       {
14678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (std::exception& e) {
14681       {
14682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690   jresult = (void *)result;
14691
14692   //argout typemap for const std::string&
14693
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14699   void * jresult ;
14700   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14701   Dali::Property::Index arg2 ;
14702   Dali::Property::Value *result = 0 ;
14703
14704   arg1 = (Dali::Property::Map *)jarg1;
14705   arg2 = (Dali::Property::Index)jarg2;
14706   {
14707     try {
14708       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14709     } catch (std::out_of_range& e) {
14710       {
14711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (std::exception& e) {
14714       {
14715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723   jresult = (void *)result;
14724   return jresult;
14725 }
14726
14727
14728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14729   void * jresult ;
14730   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14731   Dali::Property::Map *arg2 = 0 ;
14732   Dali::Property::Map *result = 0 ;
14733
14734   arg1 = (Dali::Property::Map *)jarg1;
14735   arg2 = (Dali::Property::Map *)jarg2;
14736   if (!arg2) {
14737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14738     return 0;
14739   }
14740   {
14741     try {
14742       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14743     } catch (std::out_of_range& e) {
14744       {
14745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14746       };
14747     } catch (std::exception& e) {
14748       {
14749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14750       };
14751     } catch (...) {
14752       {
14753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14754       };
14755     }
14756   }
14757   jresult = (void *)result;
14758   return jresult;
14759 }
14760
14761
14762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14763   void * jresult ;
14764   Dali::Property::Value *result = 0 ;
14765
14766   {
14767     try {
14768       result = (Dali::Property::Value *)new Dali::Property::Value();
14769     } catch (std::out_of_range& e) {
14770       {
14771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (std::exception& e) {
14774       {
14775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (...) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14780       };
14781     }
14782   }
14783   jresult = (void *)result;
14784   return jresult;
14785 }
14786
14787
14788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14789   void * jresult ;
14790   bool arg1 ;
14791   Dali::Property::Value *result = 0 ;
14792
14793   arg1 = jarg1 ? true : false;
14794   {
14795     try {
14796       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14797     } catch (std::out_of_range& e) {
14798       {
14799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (std::exception& e) {
14802       {
14803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14804       };
14805     } catch (...) {
14806       {
14807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14808       };
14809     }
14810   }
14811   jresult = (void *)result;
14812   return jresult;
14813 }
14814
14815
14816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14817   void * jresult ;
14818   int arg1 ;
14819   Dali::Property::Value *result = 0 ;
14820
14821   arg1 = (int)jarg1;
14822   {
14823     try {
14824       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14825     } catch (std::out_of_range& e) {
14826       {
14827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14828       };
14829     } catch (std::exception& e) {
14830       {
14831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (...) {
14834       {
14835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14836       };
14837     }
14838   }
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14845   void * jresult ;
14846   float arg1 ;
14847   Dali::Property::Value *result = 0 ;
14848
14849   arg1 = (float)jarg1;
14850   {
14851     try {
14852       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14853     } catch (std::out_of_range& e) {
14854       {
14855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14856       };
14857     } catch (std::exception& e) {
14858       {
14859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (...) {
14862       {
14863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14864       };
14865     }
14866   }
14867   jresult = (void *)result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14873   void * jresult ;
14874   Dali::Vector2 *arg1 = 0 ;
14875   Dali::Property::Value *result = 0 ;
14876
14877   arg1 = (Dali::Vector2 *)jarg1;
14878   if (!arg1) {
14879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14880     return 0;
14881   }
14882   {
14883     try {
14884       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14885     } catch (std::out_of_range& e) {
14886       {
14887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14888       };
14889     } catch (std::exception& e) {
14890       {
14891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (...) {
14894       {
14895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14896       };
14897     }
14898   }
14899   jresult = (void *)result;
14900   return jresult;
14901 }
14902
14903
14904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14905   void * jresult ;
14906   Dali::Vector3 *arg1 = 0 ;
14907   Dali::Property::Value *result = 0 ;
14908
14909   arg1 = (Dali::Vector3 *)jarg1;
14910   if (!arg1) {
14911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14912     return 0;
14913   }
14914   {
14915     try {
14916       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14917     } catch (std::out_of_range& e) {
14918       {
14919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14920       };
14921     } catch (std::exception& e) {
14922       {
14923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14924       };
14925     } catch (...) {
14926       {
14927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14928       };
14929     }
14930   }
14931   jresult = (void *)result;
14932   return jresult;
14933 }
14934
14935
14936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14937   void * jresult ;
14938   Dali::Vector4 *arg1 = 0 ;
14939   Dali::Property::Value *result = 0 ;
14940
14941   arg1 = (Dali::Vector4 *)jarg1;
14942   if (!arg1) {
14943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14944     return 0;
14945   }
14946   {
14947     try {
14948       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14949     } catch (std::out_of_range& e) {
14950       {
14951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14952       };
14953     } catch (std::exception& e) {
14954       {
14955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (...) {
14958       {
14959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14960       };
14961     }
14962   }
14963   jresult = (void *)result;
14964   return jresult;
14965 }
14966
14967
14968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14969   void * jresult ;
14970   Dali::Matrix3 *arg1 = 0 ;
14971   Dali::Property::Value *result = 0 ;
14972
14973   arg1 = (Dali::Matrix3 *)jarg1;
14974   if (!arg1) {
14975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14976     return 0;
14977   }
14978   {
14979     try {
14980       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14981     } catch (std::out_of_range& e) {
14982       {
14983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14984       };
14985     } catch (std::exception& e) {
14986       {
14987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (...) {
14990       {
14991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14992       };
14993     }
14994   }
14995   jresult = (void *)result;
14996   return jresult;
14997 }
14998
14999
15000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15001   void * jresult ;
15002   Dali::Matrix *arg1 = 0 ;
15003   Dali::Property::Value *result = 0 ;
15004
15005   arg1 = (Dali::Matrix *)jarg1;
15006   if (!arg1) {
15007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15008     return 0;
15009   }
15010   {
15011     try {
15012       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15013     } catch (std::out_of_range& e) {
15014       {
15015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15016       };
15017     } catch (std::exception& e) {
15018       {
15019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (...) {
15022       {
15023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15024       };
15025     }
15026   }
15027   jresult = (void *)result;
15028   return jresult;
15029 }
15030
15031
15032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15033   void * jresult ;
15034   Dali::Rect< int > *arg1 = 0 ;
15035   Dali::Property::Value *result = 0 ;
15036
15037   arg1 = (Dali::Rect< int > *)jarg1;
15038   if (!arg1) {
15039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15040     return 0;
15041   }
15042   {
15043     try {
15044       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15045     } catch (std::out_of_range& e) {
15046       {
15047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15048       };
15049     } catch (std::exception& e) {
15050       {
15051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15052       };
15053     } catch (...) {
15054       {
15055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15056       };
15057     }
15058   }
15059   jresult = (void *)result;
15060   return jresult;
15061 }
15062
15063
15064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15065   void * jresult ;
15066   Dali::AngleAxis *arg1 = 0 ;
15067   Dali::Property::Value *result = 0 ;
15068
15069   arg1 = (Dali::AngleAxis *)jarg1;
15070   if (!arg1) {
15071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15072     return 0;
15073   }
15074   {
15075     try {
15076       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15077     } catch (std::out_of_range& e) {
15078       {
15079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15080       };
15081     } catch (std::exception& e) {
15082       {
15083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15084       };
15085     } catch (...) {
15086       {
15087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15088       };
15089     }
15090   }
15091   jresult = (void *)result;
15092   return jresult;
15093 }
15094
15095
15096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15097   void * jresult ;
15098   Dali::Quaternion *arg1 = 0 ;
15099   Dali::Property::Value *result = 0 ;
15100
15101   arg1 = (Dali::Quaternion *)jarg1;
15102   if (!arg1) {
15103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15104     return 0;
15105   }
15106   {
15107     try {
15108       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15109     } catch (std::out_of_range& e) {
15110       {
15111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15112       };
15113     } catch (std::exception& e) {
15114       {
15115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15116       };
15117     } catch (...) {
15118       {
15119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15120       };
15121     }
15122   }
15123   jresult = (void *)result;
15124   return jresult;
15125 }
15126
15127
15128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15129   void * jresult ;
15130   std::string *arg1 = 0 ;
15131   Dali::Property::Value *result = 0 ;
15132
15133   if (!jarg1) {
15134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15135     return 0;
15136   }
15137   std::string arg1_str(jarg1);
15138   arg1 = &arg1_str;
15139   {
15140     try {
15141       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15142     } catch (std::out_of_range& e) {
15143       {
15144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15145       };
15146     } catch (std::exception& e) {
15147       {
15148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15149       };
15150     } catch (...) {
15151       {
15152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15153       };
15154     }
15155   }
15156   jresult = (void *)result;
15157
15158   //argout typemap for const std::string&
15159
15160   return jresult;
15161 }
15162
15163
15164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15165   void * jresult ;
15166   Dali::Property::Array *arg1 = 0 ;
15167   Dali::Property::Value *result = 0 ;
15168
15169   arg1 = (Dali::Property::Array *)jarg1;
15170   if (!arg1) {
15171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15172     return 0;
15173   }
15174   {
15175     try {
15176       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (...) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15188       };
15189     }
15190   }
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15197   void * jresult ;
15198   Dali::Property::Map *arg1 = 0 ;
15199   Dali::Property::Value *result = 0 ;
15200
15201   arg1 = (Dali::Property::Map *)jarg1;
15202   if (!arg1) {
15203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15204     return 0;
15205   }
15206   {
15207     try {
15208       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15209     } catch (std::out_of_range& e) {
15210       {
15211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15212       };
15213     } catch (std::exception& e) {
15214       {
15215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15216       };
15217     } catch (...) {
15218       {
15219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15220       };
15221     }
15222   }
15223   jresult = (void *)result;
15224   return jresult;
15225 }
15226
15227
15228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15229   void * jresult ;
15230   Dali::Property::Type arg1 ;
15231   Dali::Property::Value *result = 0 ;
15232
15233   arg1 = (Dali::Property::Type)jarg1;
15234   {
15235     try {
15236       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15237     } catch (std::out_of_range& e) {
15238       {
15239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (std::exception& e) {
15242       {
15243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251   jresult = (void *)result;
15252   return jresult;
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15257   void * jresult ;
15258   Dali::Property::Value *arg1 = 0 ;
15259   Dali::Property::Value *result = 0 ;
15260
15261   arg1 = (Dali::Property::Value *)jarg1;
15262   if (!arg1) {
15263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15264     return 0;
15265   }
15266   {
15267     try {
15268       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15280       };
15281     }
15282   }
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15289   void * jresult ;
15290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15291   Dali::Property::Value *arg2 = 0 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Value *)jarg1;
15295   arg2 = (Dali::Property::Value *)jarg2;
15296   if (!arg2) {
15297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15298     return 0;
15299   }
15300   {
15301     try {
15302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15303     } catch (std::out_of_range& e) {
15304       {
15305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (std::exception& e) {
15308       {
15309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15323   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15324
15325   arg1 = (Dali::Property::Value *)jarg1;
15326   {
15327     try {
15328       delete arg1;
15329     } catch (std::out_of_range& e) {
15330       {
15331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15332       };
15333     } catch (std::exception& e) {
15334       {
15335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15336       };
15337     } catch (...) {
15338       {
15339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15340       };
15341     }
15342   }
15343 }
15344
15345
15346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15347   int jresult ;
15348   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15349   Dali::Property::Type result;
15350
15351   arg1 = (Dali::Property::Value *)jarg1;
15352   {
15353     try {
15354       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15355     } catch (std::out_of_range& e) {
15356       {
15357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (std::exception& e) {
15360       {
15361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (...) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15366       };
15367     }
15368   }
15369   jresult = (int)result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15375   unsigned int jresult ;
15376   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15377   bool *arg2 = 0 ;
15378   bool result;
15379
15380   arg1 = (Dali::Property::Value *)jarg1;
15381   arg2 = (bool *)jarg2;
15382   {
15383     try {
15384       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15385     } catch (std::out_of_range& e) {
15386       {
15387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (std::exception& e) {
15390       {
15391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399   jresult = result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15405   unsigned int jresult ;
15406   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15407   float *arg2 = 0 ;
15408   bool result;
15409
15410   arg1 = (Dali::Property::Value *)jarg1;
15411   arg2 = (float *)jarg2;
15412   {
15413     try {
15414       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15415     } catch (std::out_of_range& e) {
15416       {
15417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15418       };
15419     } catch (std::exception& e) {
15420       {
15421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15422       };
15423     } catch (...) {
15424       {
15425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15426       };
15427     }
15428   }
15429   jresult = result;
15430   return jresult;
15431 }
15432
15433
15434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15435   unsigned int jresult ;
15436   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15437   int *arg2 = 0 ;
15438   bool result;
15439
15440   arg1 = (Dali::Property::Value *)jarg1;
15441   arg2 = (int *)jarg2;
15442   {
15443     try {
15444       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15445     } catch (std::out_of_range& e) {
15446       {
15447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15448       };
15449     } catch (std::exception& e) {
15450       {
15451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15452       };
15453     } catch (...) {
15454       {
15455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15456       };
15457     }
15458   }
15459   jresult = result;
15460   return jresult;
15461 }
15462
15463
15464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15465   unsigned int jresult ;
15466   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15467   Dali::Rect< int > *arg2 = 0 ;
15468   bool result;
15469
15470   arg1 = (Dali::Property::Value *)jarg1;
15471   arg2 = (Dali::Rect< int > *)jarg2;
15472   if (!arg2) {
15473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15474     return 0;
15475   }
15476   {
15477     try {
15478       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15479     } catch (std::out_of_range& e) {
15480       {
15481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (std::exception& e) {
15484       {
15485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15486       };
15487     } catch (...) {
15488       {
15489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15490       };
15491     }
15492   }
15493   jresult = result;
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15499   unsigned int jresult ;
15500   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15501   Dali::Vector2 *arg2 = 0 ;
15502   bool result;
15503
15504   arg1 = (Dali::Property::Value *)jarg1;
15505   arg2 = (Dali::Vector2 *)jarg2;
15506   if (!arg2) {
15507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15508     return 0;
15509   }
15510   {
15511     try {
15512       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15513     } catch (std::out_of_range& e) {
15514       {
15515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15516       };
15517     } catch (std::exception& e) {
15518       {
15519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15520       };
15521     } catch (...) {
15522       {
15523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15524       };
15525     }
15526   }
15527   jresult = result;
15528   return jresult;
15529 }
15530
15531
15532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15533   unsigned int jresult ;
15534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15535   Dali::Vector3 *arg2 = 0 ;
15536   bool result;
15537
15538   arg1 = (Dali::Property::Value *)jarg1;
15539   arg2 = (Dali::Vector3 *)jarg2;
15540   if (!arg2) {
15541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15542     return 0;
15543   }
15544   {
15545     try {
15546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15547     } catch (std::out_of_range& e) {
15548       {
15549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15550       };
15551     } catch (std::exception& e) {
15552       {
15553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15554       };
15555     } catch (...) {
15556       {
15557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15558       };
15559     }
15560   }
15561   jresult = result;
15562   return jresult;
15563 }
15564
15565
15566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15567   unsigned int jresult ;
15568   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15569   Dali::Vector4 *arg2 = 0 ;
15570   bool result;
15571
15572   arg1 = (Dali::Property::Value *)jarg1;
15573   arg2 = (Dali::Vector4 *)jarg2;
15574   if (!arg2) {
15575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15576     return 0;
15577   }
15578   {
15579     try {
15580       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15581     } catch (std::out_of_range& e) {
15582       {
15583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15584       };
15585     } catch (std::exception& e) {
15586       {
15587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15588       };
15589     } catch (...) {
15590       {
15591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15592       };
15593     }
15594   }
15595   jresult = result;
15596   return jresult;
15597 }
15598
15599
15600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15601   unsigned int jresult ;
15602   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15603   Dali::Matrix3 *arg2 = 0 ;
15604   bool result;
15605
15606   arg1 = (Dali::Property::Value *)jarg1;
15607   arg2 = (Dali::Matrix3 *)jarg2;
15608   if (!arg2) {
15609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15610     return 0;
15611   }
15612   {
15613     try {
15614       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15615     } catch (std::out_of_range& e) {
15616       {
15617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15618       };
15619     } catch (std::exception& e) {
15620       {
15621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15622       };
15623     } catch (...) {
15624       {
15625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15626       };
15627     }
15628   }
15629   jresult = result;
15630   return jresult;
15631 }
15632
15633
15634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15635   unsigned int jresult ;
15636   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15637   Dali::Matrix *arg2 = 0 ;
15638   bool result;
15639
15640   arg1 = (Dali::Property::Value *)jarg1;
15641   arg2 = (Dali::Matrix *)jarg2;
15642   if (!arg2) {
15643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15644     return 0;
15645   }
15646   {
15647     try {
15648       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15649     } catch (std::out_of_range& e) {
15650       {
15651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15652       };
15653     } catch (std::exception& e) {
15654       {
15655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15656       };
15657     } catch (...) {
15658       {
15659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15660       };
15661     }
15662   }
15663   jresult = result;
15664   return jresult;
15665 }
15666
15667
15668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15669   unsigned int jresult ;
15670   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15671   Dali::AngleAxis *arg2 = 0 ;
15672   bool result;
15673
15674   arg1 = (Dali::Property::Value *)jarg1;
15675   arg2 = (Dali::AngleAxis *)jarg2;
15676   if (!arg2) {
15677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15678     return 0;
15679   }
15680   {
15681     try {
15682       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15683     } catch (std::out_of_range& e) {
15684       {
15685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15686       };
15687     } catch (std::exception& e) {
15688       {
15689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15690       };
15691     } catch (...) {
15692       {
15693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15694       };
15695     }
15696   }
15697   jresult = result;
15698   return jresult;
15699 }
15700
15701
15702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15703   unsigned int jresult ;
15704   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15705   Dali::Quaternion *arg2 = 0 ;
15706   bool result;
15707
15708   arg1 = (Dali::Property::Value *)jarg1;
15709   arg2 = (Dali::Quaternion *)jarg2;
15710   if (!arg2) {
15711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15712     return 0;
15713   }
15714   {
15715     try {
15716       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15717     } catch (std::out_of_range& e) {
15718       {
15719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (std::exception& e) {
15722       {
15723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15724       };
15725     } catch (...) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15728       };
15729     }
15730   }
15731   jresult = result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15737   unsigned int jresult ;
15738   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15739   std::string *arg2 = 0 ;
15740   bool result;
15741
15742   arg1 = (Dali::Property::Value *)jarg1;
15743
15744   //typemap in
15745   std::string temp;
15746   arg2 = &temp;
15747
15748   {
15749     try {
15750       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15751     } catch (std::out_of_range& e) {
15752       {
15753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (std::exception& e) {
15756       {
15757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (...) {
15760       {
15761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15762       };
15763     }
15764   }
15765   jresult = result;
15766
15767   //Typemap argout in c++ file.
15768   //This will convert c++ string to c# string
15769   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15770
15771   return jresult;
15772 }
15773
15774
15775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15776   unsigned int jresult ;
15777   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15778   Dali::Property::Array *arg2 = 0 ;
15779   bool result;
15780
15781   arg1 = (Dali::Property::Value *)jarg1;
15782   arg2 = (Dali::Property::Array *)jarg2;
15783   if (!arg2) {
15784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15785     return 0;
15786   }
15787   {
15788     try {
15789       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15790     } catch (std::out_of_range& e) {
15791       {
15792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15793       };
15794     } catch (std::exception& e) {
15795       {
15796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15801       };
15802     }
15803   }
15804   jresult = result;
15805   return jresult;
15806 }
15807
15808
15809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15810   unsigned int jresult ;
15811   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15812   Dali::Property::Map *arg2 = 0 ;
15813   bool result;
15814
15815   arg1 = (Dali::Property::Value *)jarg1;
15816   arg2 = (Dali::Property::Map *)jarg2;
15817   if (!arg2) {
15818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15819     return 0;
15820   }
15821   {
15822     try {
15823       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15824     } catch (std::out_of_range& e) {
15825       {
15826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15827       };
15828     } catch (std::exception& e) {
15829       {
15830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15831       };
15832     } catch (...) {
15833       {
15834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15835       };
15836     }
15837   }
15838   jresult = result;
15839   return jresult;
15840 }
15841
15842
15843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15844   void * jresult ;
15845   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15846   Dali::Property::Array *result = 0 ;
15847
15848   arg1 = (Dali::Property::Value *)jarg1;
15849   {
15850     try {
15851       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (...) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15863       };
15864     }
15865   }
15866   jresult = (void *)result;
15867   return jresult;
15868 }
15869
15870
15871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15872   void * jresult ;
15873   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15874   Dali::Property::Map *result = 0 ;
15875
15876   arg1 = (Dali::Property::Value *)jarg1;
15877   {
15878     try {
15879       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15880     } catch (std::out_of_range& e) {
15881       {
15882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15883       };
15884     } catch (std::exception& e) {
15885       {
15886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15887       };
15888     } catch (...) {
15889       {
15890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15891       };
15892     }
15893   }
15894   jresult = (void *)result;
15895   return jresult;
15896 }
15897
15898
15899 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15900   char * jresult ;
15901   Dali::Property::Type arg1 ;
15902   char *result = 0 ;
15903
15904   arg1 = (Dali::Property::Type)jarg1;
15905   {
15906     try {
15907       result = (char *)Dali::PropertyTypes::GetName(arg1);
15908     } catch (std::out_of_range& e) {
15909       {
15910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15911       };
15912     } catch (std::exception& e) {
15913       {
15914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (...) {
15917       {
15918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15919       };
15920     }
15921   }
15922   jresult = SWIG_csharp_string_callback((const char *)result);
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15928   unsigned int jresult ;
15929   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15930   std::string *arg2 = 0 ;
15931   Dali::Property::Map *arg3 = 0 ;
15932   bool result;
15933
15934   arg1 = (Dali::BaseObject *)jarg1;
15935   if (!jarg2) {
15936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15937     return 0;
15938   }
15939   std::string arg2_str(jarg2);
15940   arg2 = &arg2_str;
15941   arg3 = (Dali::Property::Map *)jarg3;
15942   if (!arg3) {
15943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15944     return 0;
15945   }
15946   {
15947     try {
15948       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (...) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15960       };
15961     }
15962   }
15963   jresult = result;
15964
15965   //argout typemap for const std::string&
15966
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15972   char * jresult ;
15973   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15974   std::string *result = 0 ;
15975
15976   arg1 = (Dali::BaseObject *)jarg1;
15977   {
15978     try {
15979       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15980     } catch (std::out_of_range& e) {
15981       {
15982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15983       };
15984     } catch (std::exception& e) {
15985       {
15986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15987       };
15988     } catch (...) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15991       };
15992     }
15993   }
15994   jresult = SWIG_csharp_string_callback(result->c_str());
15995   return jresult;
15996 }
15997
15998
15999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16000   unsigned int jresult ;
16001   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16002   Dali::TypeInfo *arg2 = 0 ;
16003   bool result;
16004
16005   arg1 = (Dali::BaseObject *)jarg1;
16006   arg2 = (Dali::TypeInfo *)jarg2;
16007   if (!arg2) {
16008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16009     return 0;
16010   }
16011   {
16012     try {
16013       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16014     } catch (std::out_of_range& e) {
16015       {
16016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16017       };
16018     } catch (std::exception& e) {
16019       {
16020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16021       };
16022     } catch (...) {
16023       {
16024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16025       };
16026     }
16027   }
16028   jresult = result;
16029   return jresult;
16030 }
16031
16032
16033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16034   unsigned int jresult ;
16035   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16036   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16037   std::string *arg3 = 0 ;
16038   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16039   bool result;
16040
16041   arg1 = (Dali::BaseObject *)jarg1;
16042   arg2 = (ConnectionTrackerInterface *)jarg2;
16043   if (!jarg3) {
16044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16045     return 0;
16046   }
16047   std::string arg3_str(jarg3);
16048   arg3 = &arg3_str;
16049   arg4 = (FunctorDelegate *)jarg4;
16050   {
16051     try {
16052       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16053     } catch (std::out_of_range& e) {
16054       {
16055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16056       };
16057     } catch (std::exception& e) {
16058       {
16059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16060       };
16061     } catch (...) {
16062       {
16063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16064       };
16065     }
16066   }
16067   jresult = result;
16068
16069   //argout typemap for const std::string&
16070
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16076   void * jresult ;
16077   Dali::BaseHandle *arg1 = 0 ;
16078   Dali::BaseObject *result = 0 ;
16079
16080   arg1 = (Dali::BaseHandle *)jarg1;
16081   if (!arg1) {
16082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16083     return 0;
16084   }
16085   {
16086     try {
16087       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16088     } catch (std::out_of_range& e) {
16089       {
16090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16091       };
16092     } catch (std::exception& e) {
16093       {
16094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16095       };
16096     } catch (...) {
16097       {
16098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16099       };
16100     }
16101   }
16102   jresult = (void *)result;
16103   return jresult;
16104 }
16105
16106
16107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16108   void * jresult ;
16109   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16110   Dali::BaseHandle *result = 0 ;
16111
16112   arg1 = (Dali::BaseObject *)jarg1;
16113   {
16114     try {
16115       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16116     } catch (std::out_of_range& e) {
16117       {
16118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16119       };
16120     } catch (std::exception& e) {
16121       {
16122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16123       };
16124     } catch (...) {
16125       {
16126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16127       };
16128     }
16129   }
16130   jresult = (void *)result;
16131   return jresult;
16132 }
16133
16134
16135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16136   void * jresult ;
16137   Dali::BaseHandle *result = 0 ;
16138
16139   {
16140     try {
16141       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16142     } catch (std::out_of_range& e) {
16143       {
16144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (std::exception& e) {
16147       {
16148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16162   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16163
16164   arg1 = (Dali::BaseHandle *)jarg1;
16165   {
16166     try {
16167       delete arg1;
16168     } catch (std::out_of_range& e) {
16169       {
16170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16171       };
16172     } catch (std::exception& e) {
16173       {
16174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16175       };
16176     } catch (...) {
16177       {
16178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16179       };
16180     }
16181   }
16182 }
16183
16184
16185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16186   void * jresult ;
16187   Dali::BaseHandle *arg1 = 0 ;
16188   Dali::BaseHandle *result = 0 ;
16189
16190   arg1 = (Dali::BaseHandle *)jarg1;
16191   if (!arg1) {
16192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16193     return 0;
16194   }
16195   {
16196     try {
16197       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16198     } catch (std::out_of_range& e) {
16199       {
16200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (std::exception& e) {
16203       {
16204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (...) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16209       };
16210     }
16211   }
16212   jresult = (void *)result;
16213   return jresult;
16214 }
16215
16216
16217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16218   void * jresult ;
16219   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16220   Dali::BaseHandle *arg2 = 0 ;
16221   Dali::BaseHandle *result = 0 ;
16222
16223   arg1 = (Dali::BaseHandle *)jarg1;
16224   arg2 = (Dali::BaseHandle *)jarg2;
16225   if (!arg2) {
16226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16227     return 0;
16228   }
16229   {
16230     try {
16231       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16232     } catch (std::out_of_range& e) {
16233       {
16234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (std::exception& e) {
16237       {
16238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16239       };
16240     } catch (...) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16243       };
16244     }
16245   }
16246   jresult = (void *)result;
16247   return jresult;
16248 }
16249
16250
16251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16252   unsigned int jresult ;
16253   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16254   std::string *arg2 = 0 ;
16255   Dali::Property::Map *arg3 = 0 ;
16256   bool result;
16257
16258   arg1 = (Dali::BaseHandle *)jarg1;
16259   if (!jarg2) {
16260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16261     return 0;
16262   }
16263   std::string arg2_str(jarg2);
16264   arg2 = &arg2_str;
16265   arg3 = (Dali::Property::Map *)jarg3;
16266   if (!arg3) {
16267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16268     return 0;
16269   }
16270   {
16271     try {
16272       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16273     } catch (std::out_of_range& e) {
16274       {
16275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16276       };
16277     } catch (std::exception& e) {
16278       {
16279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (...) {
16282       {
16283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16284       };
16285     }
16286   }
16287   jresult = result;
16288
16289   //argout typemap for const std::string&
16290
16291   return jresult;
16292 }
16293
16294
16295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16296   char * jresult ;
16297   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16298   std::string *result = 0 ;
16299
16300   arg1 = (Dali::BaseHandle *)jarg1;
16301   {
16302     try {
16303       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16304     } catch (std::out_of_range& e) {
16305       {
16306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16307       };
16308     } catch (std::exception& e) {
16309       {
16310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16311       };
16312     } catch (...) {
16313       {
16314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16315       };
16316     }
16317   }
16318   jresult = SWIG_csharp_string_callback(result->c_str());
16319   return jresult;
16320 }
16321
16322
16323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16324   unsigned int jresult ;
16325   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16326   Dali::TypeInfo *arg2 = 0 ;
16327   bool result;
16328
16329   arg1 = (Dali::BaseHandle *)jarg1;
16330   arg2 = (Dali::TypeInfo *)jarg2;
16331   if (!arg2) {
16332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16333     return 0;
16334   }
16335   {
16336     try {
16337       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16338     } catch (std::out_of_range& e) {
16339       {
16340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16341       };
16342     } catch (std::exception& e) {
16343       {
16344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16345       };
16346     } catch (...) {
16347       {
16348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16349       };
16350     }
16351   }
16352   jresult = result;
16353   return jresult;
16354 }
16355
16356
16357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16358   void * jresult ;
16359   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16360   Dali::BaseObject *result = 0 ;
16361
16362   arg1 = (Dali::BaseHandle *)jarg1;
16363   {
16364     try {
16365       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16366     } catch (std::out_of_range& e) {
16367       {
16368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16369       };
16370     } catch (std::exception& e) {
16371       {
16372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16373       };
16374     } catch (...) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16377       };
16378     }
16379   }
16380   jresult = (void *)result;
16381   return jresult;
16382 }
16383
16384
16385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16386   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16387
16388   arg1 = (Dali::BaseHandle *)jarg1;
16389   {
16390     try {
16391       (arg1)->Reset();
16392     } catch (std::out_of_range& e) {
16393       {
16394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16395       };
16396     } catch (std::exception& e) {
16397       {
16398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16399       };
16400     } catch (...) {
16401       {
16402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16403       };
16404     }
16405   }
16406 }
16407
16408
16409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16410   unsigned int jresult ;
16411   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16412   Dali::BaseHandle *arg2 = 0 ;
16413   bool result;
16414
16415   arg1 = (Dali::BaseHandle *)jarg1;
16416   arg2 = (Dali::BaseHandle *)jarg2;
16417   if (!arg2) {
16418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16419     return 0;
16420   }
16421   {
16422     try {
16423       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16424     } catch (std::out_of_range& e) {
16425       {
16426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16427       };
16428     } catch (std::exception& e) {
16429       {
16430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16431       };
16432     } catch (...) {
16433       {
16434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16435       };
16436     }
16437   }
16438   jresult = result;
16439   return jresult;
16440 }
16441
16442
16443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16444   unsigned int jresult ;
16445   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16446   Dali::BaseHandle *arg2 = 0 ;
16447   bool result;
16448
16449   arg1 = (Dali::BaseHandle *)jarg1;
16450   arg2 = (Dali::BaseHandle *)jarg2;
16451   if (!arg2) {
16452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16453     return 0;
16454   }
16455   {
16456     try {
16457       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16458     } catch (std::out_of_range& e) {
16459       {
16460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16461       };
16462     } catch (std::exception& e) {
16463       {
16464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16465       };
16466     } catch (...) {
16467       {
16468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16469       };
16470     }
16471   }
16472   jresult = result;
16473   return jresult;
16474 }
16475
16476
16477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16478   void * jresult ;
16479   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16480   Dali::RefObject *result = 0 ;
16481
16482   arg1 = (Dali::BaseHandle *)jarg1;
16483   {
16484     try {
16485       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16486     } catch (std::out_of_range& e) {
16487       {
16488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16489       };
16490     } catch (std::exception& e) {
16491       {
16492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16493       };
16494     } catch (...) {
16495       {
16496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16497       };
16498     }
16499   }
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16506   unsigned int jresult ;
16507   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16508   bool result;
16509
16510   arg1 = (Dali::BaseHandle *)jarg1;
16511   {
16512     try {
16513       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16514     } catch (std::out_of_range& e) {
16515       {
16516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16517       };
16518     } catch (std::exception& e) {
16519       {
16520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16521       };
16522     } catch (...) {
16523       {
16524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16525       };
16526     }
16527   }
16528   jresult = result;
16529   return jresult;
16530 }
16531
16532
16533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16534   unsigned int jresult ;
16535   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16536   Dali::BaseHandle *arg2 = 0 ;
16537   bool result;
16538
16539   arg1 = (Dali::BaseHandle *)jarg1;
16540   arg2 = (Dali::BaseHandle *)jarg2;
16541   if (!arg2) {
16542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16543     return 0;
16544   }
16545   {
16546     try {
16547       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16548     } catch (std::out_of_range& e) {
16549       {
16550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (std::exception& e) {
16553       {
16554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562   jresult = result;
16563   return jresult;
16564 }
16565
16566
16567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16568   unsigned int jresult ;
16569   Dali::BaseHandle *arg1 = 0 ;
16570   Dali::BaseHandle *arg2 = 0 ;
16571   bool result;
16572
16573   arg1 = (Dali::BaseHandle *)jarg1;
16574   if (!arg1) {
16575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16576     return 0;
16577   }
16578   arg2 = (Dali::BaseHandle *)jarg2;
16579   if (!arg2) {
16580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16581     return 0;
16582   }
16583   {
16584     try {
16585       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16586     } catch (std::out_of_range& e) {
16587       {
16588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (std::exception& e) {
16591       {
16592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600   jresult = result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16606   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16607
16608   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16609   {
16610     try {
16611       delete arg1;
16612     } catch (std::out_of_range& e) {
16613       {
16614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16615       };
16616     } catch (std::exception& e) {
16617       {
16618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16619       };
16620     } catch (...) {
16621       {
16622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16623       };
16624     }
16625   }
16626 }
16627
16628
16629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16630   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16631   SlotObserver *arg2 = (SlotObserver *) 0 ;
16632   CallbackBase *arg3 = (CallbackBase *) 0 ;
16633
16634   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16635   arg2 = (SlotObserver *)jarg2;
16636   arg3 = (CallbackBase *)jarg3;
16637   {
16638     try {
16639       (arg1)->SignalConnected(arg2,arg3);
16640     } catch (std::out_of_range& e) {
16641       {
16642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16643       };
16644     } catch (std::exception& e) {
16645       {
16646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16647       };
16648     } catch (...) {
16649       {
16650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16651       };
16652     }
16653   }
16654 }
16655
16656
16657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16658   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16659
16660   arg1 = (Dali::SignalObserver *)jarg1;
16661   {
16662     try {
16663       delete arg1;
16664     } catch (std::out_of_range& e) {
16665       {
16666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16667       };
16668     } catch (std::exception& e) {
16669       {
16670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16682   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16683   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16684   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16685
16686   arg1 = (Dali::SignalObserver *)jarg1;
16687   arg2 = (Dali::SlotObserver *)jarg2;
16688   arg3 = (Dali::CallbackBase *)jarg3;
16689   {
16690     try {
16691       (arg1)->SignalDisconnected(arg2,arg3);
16692     } catch (std::out_of_range& e) {
16693       {
16694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16695       };
16696     } catch (std::exception& e) {
16697       {
16698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16699       };
16700     } catch (...) {
16701       {
16702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16703       };
16704     }
16705   }
16706 }
16707
16708
16709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16710   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16711
16712   arg1 = (Dali::SlotObserver *)jarg1;
16713   {
16714     try {
16715       delete arg1;
16716     } catch (std::out_of_range& e) {
16717       {
16718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16719       };
16720     } catch (std::exception& e) {
16721       {
16722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16723       };
16724     } catch (...) {
16725       {
16726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16727       };
16728     }
16729   }
16730 }
16731
16732
16733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16734   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16735   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16736
16737   arg1 = (Dali::SlotObserver *)jarg1;
16738   arg2 = (Dali::CallbackBase *)jarg2;
16739   {
16740     try {
16741       (arg1)->SlotDisconnected(arg2);
16742     } catch (std::out_of_range& e) {
16743       {
16744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16745       };
16746     } catch (std::exception& e) {
16747       {
16748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16749       };
16750     } catch (...) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16753       };
16754     }
16755   }
16756 }
16757
16758
16759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16760   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16761
16762   arg1 = (Dali::ConnectionTracker *)jarg1;
16763   {
16764     try {
16765       delete arg1;
16766     } catch (std::out_of_range& e) {
16767       {
16768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16769       };
16770     } catch (std::exception& e) {
16771       {
16772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16773       };
16774     } catch (...) {
16775       {
16776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16777       };
16778     }
16779   }
16780 }
16781
16782
16783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16784   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16785
16786   arg1 = (Dali::ConnectionTracker *)jarg1;
16787   {
16788     try {
16789       (arg1)->DisconnectAll();
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16797       };
16798     } catch (...) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16801       };
16802     }
16803   }
16804 }
16805
16806
16807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16808   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16809   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16810   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16811
16812   arg1 = (Dali::ConnectionTracker *)jarg1;
16813   arg2 = (Dali::SlotObserver *)jarg2;
16814   arg3 = (Dali::CallbackBase *)jarg3;
16815   {
16816     try {
16817       (arg1)->SignalConnected(arg2,arg3);
16818     } catch (std::out_of_range& e) {
16819       {
16820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16821       };
16822     } catch (std::exception& e) {
16823       {
16824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16825       };
16826     } catch (...) {
16827       {
16828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16829       };
16830     }
16831   }
16832 }
16833
16834
16835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16836   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16837   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16838   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16839
16840   arg1 = (Dali::ConnectionTracker *)jarg1;
16841   arg2 = (Dali::SlotObserver *)jarg2;
16842   arg3 = (Dali::CallbackBase *)jarg3;
16843   {
16844     try {
16845       (arg1)->SignalDisconnected(arg2,arg3);
16846     } catch (std::out_of_range& e) {
16847       {
16848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16849       };
16850     } catch (std::exception& e) {
16851       {
16852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16853       };
16854     } catch (...) {
16855       {
16856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16857       };
16858     }
16859   }
16860 }
16861
16862
16863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16864   unsigned long jresult ;
16865   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16866   std::size_t result;
16867
16868   arg1 = (Dali::ConnectionTracker *)jarg1;
16869   {
16870     try {
16871       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16872     } catch (std::out_of_range& e) {
16873       {
16874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16875       };
16876     } catch (std::exception& e) {
16877       {
16878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16879       };
16880     } catch (...) {
16881       {
16882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16883       };
16884     }
16885   }
16886   jresult = (unsigned long)result;
16887   return jresult;
16888 }
16889
16890
16891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16892   void * jresult ;
16893   Dali::ObjectRegistry *result = 0 ;
16894
16895   {
16896     try {
16897       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (...) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16909       };
16910     }
16911   }
16912   jresult = (void *)result;
16913   return jresult;
16914 }
16915
16916
16917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16918   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16919
16920   arg1 = (Dali::ObjectRegistry *)jarg1;
16921   {
16922     try {
16923       delete arg1;
16924     } catch (std::out_of_range& e) {
16925       {
16926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16927       };
16928     } catch (std::exception& e) {
16929       {
16930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16931       };
16932     } catch (...) {
16933       {
16934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16935       };
16936     }
16937   }
16938 }
16939
16940
16941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16942   void * jresult ;
16943   Dali::ObjectRegistry *arg1 = 0 ;
16944   Dali::ObjectRegistry *result = 0 ;
16945
16946   arg1 = (Dali::ObjectRegistry *)jarg1;
16947   if (!arg1) {
16948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16949     return 0;
16950   }
16951   {
16952     try {
16953       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16954     } catch (std::out_of_range& e) {
16955       {
16956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16957       };
16958     } catch (std::exception& e) {
16959       {
16960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (...) {
16963       {
16964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16965       };
16966     }
16967   }
16968   jresult = (void *)result;
16969   return jresult;
16970 }
16971
16972
16973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16974   void * jresult ;
16975   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16976   Dali::ObjectRegistry *arg2 = 0 ;
16977   Dali::ObjectRegistry *result = 0 ;
16978
16979   arg1 = (Dali::ObjectRegistry *)jarg1;
16980   arg2 = (Dali::ObjectRegistry *)jarg2;
16981   if (!arg2) {
16982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16983     return 0;
16984   }
16985   {
16986     try {
16987       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16988     } catch (std::out_of_range& e) {
16989       {
16990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16991       };
16992     } catch (std::exception& e) {
16993       {
16994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (...) {
16997       {
16998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16999       };
17000     }
17001   }
17002   jresult = (void *)result;
17003   return jresult;
17004 }
17005
17006
17007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17008   void * jresult ;
17009   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17010   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17011
17012   arg1 = (Dali::ObjectRegistry *)jarg1;
17013   {
17014     try {
17015       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17016     } catch (std::out_of_range& e) {
17017       {
17018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (std::exception& e) {
17021       {
17022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030   jresult = (void *)result;
17031   return jresult;
17032 }
17033
17034
17035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17036   void * jresult ;
17037   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17038   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17039
17040   arg1 = (Dali::ObjectRegistry *)jarg1;
17041   {
17042     try {
17043       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17044     } catch (std::out_of_range& e) {
17045       {
17046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17047       };
17048     } catch (std::exception& e) {
17049       {
17050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (...) {
17053       {
17054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17055       };
17056     }
17057   }
17058   jresult = (void *)result;
17059   return jresult;
17060 }
17061
17062
17063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17064   void * jresult ;
17065   Dali::PropertyCondition *result = 0 ;
17066
17067   {
17068     try {
17069       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17070     } catch (std::out_of_range& e) {
17071       {
17072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (std::exception& e) {
17075       {
17076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17077       };
17078     } catch (...) {
17079       {
17080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17081       };
17082     }
17083   }
17084   jresult = (void *)result;
17085   return jresult;
17086 }
17087
17088
17089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17090   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17091
17092   arg1 = (Dali::PropertyCondition *)jarg1;
17093   {
17094     try {
17095       delete arg1;
17096     } catch (std::out_of_range& e) {
17097       {
17098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17099       };
17100     } catch (std::exception& e) {
17101       {
17102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17103       };
17104     } catch (...) {
17105       {
17106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17107       };
17108     }
17109   }
17110 }
17111
17112
17113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17114   void * jresult ;
17115   Dali::PropertyCondition *arg1 = 0 ;
17116   Dali::PropertyCondition *result = 0 ;
17117
17118   arg1 = (Dali::PropertyCondition *)jarg1;
17119   if (!arg1) {
17120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17121     return 0;
17122   }
17123   {
17124     try {
17125       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17126     } catch (std::out_of_range& e) {
17127       {
17128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (std::exception& e) {
17131       {
17132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (...) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17137       };
17138     }
17139   }
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17146   void * jresult ;
17147   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17148   Dali::PropertyCondition *arg2 = 0 ;
17149   Dali::PropertyCondition *result = 0 ;
17150
17151   arg1 = (Dali::PropertyCondition *)jarg1;
17152   arg2 = (Dali::PropertyCondition *)jarg2;
17153   if (!arg2) {
17154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17155     return 0;
17156   }
17157   {
17158     try {
17159       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17160     } catch (std::out_of_range& e) {
17161       {
17162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (std::exception& e) {
17165       {
17166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (...) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17171       };
17172     }
17173   }
17174   jresult = (void *)result;
17175   return jresult;
17176 }
17177
17178
17179 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17180   unsigned long jresult ;
17181   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17182   std::size_t result;
17183
17184   arg1 = (Dali::PropertyCondition *)jarg1;
17185   {
17186     try {
17187       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17188     } catch (std::out_of_range& e) {
17189       {
17190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17191       };
17192     } catch (std::exception& e) {
17193       {
17194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17195       };
17196     } catch (...) {
17197       {
17198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17199       };
17200     }
17201   }
17202   jresult = (unsigned long)result;
17203   return jresult;
17204 }
17205
17206
17207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17208   float jresult ;
17209   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17210   std::size_t arg2 ;
17211   float result;
17212
17213   arg1 = (Dali::PropertyCondition *)jarg1;
17214   arg2 = (std::size_t)jarg2;
17215   {
17216     try {
17217       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17218     } catch (std::out_of_range& e) {
17219       {
17220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (std::exception& e) {
17223       {
17224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17225       };
17226     } catch (...) {
17227       {
17228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17229       };
17230     }
17231   }
17232   jresult = result;
17233   return jresult;
17234 }
17235
17236
17237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17238   void * jresult ;
17239   float arg1 ;
17240   Dali::PropertyCondition result;
17241
17242   arg1 = (float)jarg1;
17243   {
17244     try {
17245       result = Dali::LessThanCondition(arg1);
17246     } catch (std::out_of_range& e) {
17247       {
17248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17249       };
17250     } catch (std::exception& e) {
17251       {
17252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17253       };
17254     } catch (...) {
17255       {
17256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17257       };
17258     }
17259   }
17260   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17261   return jresult;
17262 }
17263
17264
17265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17266   void * jresult ;
17267   float arg1 ;
17268   Dali::PropertyCondition result;
17269
17270   arg1 = (float)jarg1;
17271   {
17272     try {
17273       result = Dali::GreaterThanCondition(arg1);
17274     } catch (std::out_of_range& e) {
17275       {
17276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17277       };
17278     } catch (std::exception& e) {
17279       {
17280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17281       };
17282     } catch (...) {
17283       {
17284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17285       };
17286     }
17287   }
17288   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17289   return jresult;
17290 }
17291
17292
17293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17294   void * jresult ;
17295   float arg1 ;
17296   float arg2 ;
17297   Dali::PropertyCondition result;
17298
17299   arg1 = (float)jarg1;
17300   arg2 = (float)jarg2;
17301   {
17302     try {
17303       result = Dali::InsideCondition(arg1,arg2);
17304     } catch (std::out_of_range& e) {
17305       {
17306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (std::exception& e) {
17309       {
17310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17324   void * jresult ;
17325   float arg1 ;
17326   float arg2 ;
17327   Dali::PropertyCondition result;
17328
17329   arg1 = (float)jarg1;
17330   arg2 = (float)jarg2;
17331   {
17332     try {
17333       result = Dali::OutsideCondition(arg1,arg2);
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17345       };
17346     }
17347   }
17348   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17354   void * jresult ;
17355   float arg1 ;
17356   float arg2 ;
17357   Dali::PropertyCondition result;
17358
17359   arg1 = (float)jarg1;
17360   arg2 = (float)jarg2;
17361   {
17362     try {
17363       result = Dali::StepCondition(arg1,arg2);
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (...) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17375       };
17376     }
17377   }
17378   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17384   void * jresult ;
17385   float arg1 ;
17386   Dali::PropertyCondition result;
17387
17388   arg1 = (float)jarg1;
17389   {
17390     try {
17391       result = Dali::StepCondition(arg1);
17392     } catch (std::out_of_range& e) {
17393       {
17394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17395       };
17396     } catch (std::exception& e) {
17397       {
17398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17399       };
17400     } catch (...) {
17401       {
17402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17403       };
17404     }
17405   }
17406   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17412   void * jresult ;
17413   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17414   Dali::PropertyCondition result;
17415
17416   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17417   if (!arg1) {
17418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17419     return 0;
17420   }
17421   {
17422     try {
17423       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17424     } catch (std::out_of_range& e) {
17425       {
17426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (std::exception& e) {
17429       {
17430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17444   void * jresult ;
17445   Dali::PropertyNotification *result = 0 ;
17446
17447   {
17448     try {
17449       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17450     } catch (std::out_of_range& e) {
17451       {
17452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17453       };
17454     } catch (std::exception& e) {
17455       {
17456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17457       };
17458     } catch (...) {
17459       {
17460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17461       };
17462     }
17463   }
17464   jresult = (void *)result;
17465   return jresult;
17466 }
17467
17468
17469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17470   void * jresult ;
17471   Dali::BaseHandle arg1 ;
17472   Dali::BaseHandle *argp1 ;
17473   Dali::PropertyNotification result;
17474
17475   argp1 = (Dali::BaseHandle *)jarg1;
17476   if (!argp1) {
17477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17478     return 0;
17479   }
17480   arg1 = *argp1;
17481   {
17482     try {
17483       result = Dali::PropertyNotification::DownCast(arg1);
17484     } catch (std::out_of_range& e) {
17485       {
17486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (std::exception& e) {
17489       {
17490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (...) {
17493       {
17494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17495       };
17496     }
17497   }
17498   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17499   return jresult;
17500 }
17501
17502
17503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17504   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17505
17506   arg1 = (Dali::PropertyNotification *)jarg1;
17507   {
17508     try {
17509       delete arg1;
17510     } catch (std::out_of_range& e) {
17511       {
17512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17513       };
17514     } catch (std::exception& e) {
17515       {
17516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17521       };
17522     }
17523   }
17524 }
17525
17526
17527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17528   void * jresult ;
17529   Dali::PropertyNotification *arg1 = 0 ;
17530   Dali::PropertyNotification *result = 0 ;
17531
17532   arg1 = (Dali::PropertyNotification *)jarg1;
17533   if (!arg1) {
17534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17535     return 0;
17536   }
17537   {
17538     try {
17539       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17540     } catch (std::out_of_range& e) {
17541       {
17542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17543       };
17544     } catch (std::exception& e) {
17545       {
17546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (...) {
17549       {
17550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17551       };
17552     }
17553   }
17554   jresult = (void *)result;
17555   return jresult;
17556 }
17557
17558
17559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17560   void * jresult ;
17561   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17562   Dali::PropertyNotification *arg2 = 0 ;
17563   Dali::PropertyNotification *result = 0 ;
17564
17565   arg1 = (Dali::PropertyNotification *)jarg1;
17566   arg2 = (Dali::PropertyNotification *)jarg2;
17567   if (!arg2) {
17568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17569     return 0;
17570   }
17571   {
17572     try {
17573       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17574     } catch (std::out_of_range& e) {
17575       {
17576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (std::exception& e) {
17579       {
17580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17581       };
17582     } catch (...) {
17583       {
17584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17585       };
17586     }
17587   }
17588   jresult = (void *)result;
17589   return jresult;
17590 }
17591
17592
17593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17594   void * jresult ;
17595   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17596   Dali::PropertyCondition result;
17597
17598   arg1 = (Dali::PropertyNotification *)jarg1;
17599   {
17600     try {
17601       result = (arg1)->GetCondition();
17602     } catch (std::out_of_range& e) {
17603       {
17604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17605       };
17606     } catch (std::exception& e) {
17607       {
17608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17609       };
17610     } catch (...) {
17611       {
17612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17613       };
17614     }
17615   }
17616   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17617   return jresult;
17618 }
17619
17620
17621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17622   void * jresult ;
17623   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17624   Dali::Handle result;
17625
17626   arg1 = (Dali::PropertyNotification *)jarg1;
17627   {
17628     try {
17629       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17630     } catch (std::out_of_range& e) {
17631       {
17632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (std::exception& e) {
17635       {
17636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644   jresult = new Dali::Handle((const Dali::Handle &)result);
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17650   int jresult ;
17651   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17652   Dali::Property::Index result;
17653
17654   arg1 = (Dali::PropertyNotification *)jarg1;
17655   {
17656     try {
17657       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17658     } catch (std::out_of_range& e) {
17659       {
17660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17661       };
17662     } catch (std::exception& e) {
17663       {
17664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (...) {
17667       {
17668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17669       };
17670     }
17671   }
17672   jresult = result;
17673   return jresult;
17674 }
17675
17676
17677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17678   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17679   Dali::PropertyNotification::NotifyMode arg2 ;
17680
17681   arg1 = (Dali::PropertyNotification *)jarg1;
17682   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17683   {
17684     try {
17685       (arg1)->SetNotifyMode(arg2);
17686     } catch (std::out_of_range& e) {
17687       {
17688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17689       };
17690     } catch (std::exception& e) {
17691       {
17692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17693       };
17694     } catch (...) {
17695       {
17696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17697       };
17698     }
17699   }
17700 }
17701
17702
17703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17704   int jresult ;
17705   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17706   Dali::PropertyNotification::NotifyMode result;
17707
17708   arg1 = (Dali::PropertyNotification *)jarg1;
17709   {
17710     try {
17711       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17712     } catch (std::out_of_range& e) {
17713       {
17714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17715       };
17716     } catch (std::exception& e) {
17717       {
17718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17719       };
17720     } catch (...) {
17721       {
17722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17723       };
17724     }
17725   }
17726   jresult = (int)result;
17727   return jresult;
17728 }
17729
17730
17731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17732   unsigned int jresult ;
17733   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::PropertyNotification *)jarg1;
17737   {
17738     try {
17739       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (...) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17751       };
17752     }
17753   }
17754   jresult = result;
17755   return jresult;
17756 }
17757
17758
17759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17760   void * jresult ;
17761   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17762   Dali::PropertyNotifySignalType *result = 0 ;
17763
17764   arg1 = (Dali::PropertyNotification *)jarg1;
17765   {
17766     try {
17767       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17768     } catch (std::out_of_range& e) {
17769       {
17770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17771       };
17772     } catch (std::exception& e) {
17773       {
17774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17779       };
17780     }
17781   }
17782   jresult = (void *)result;
17783   return jresult;
17784 }
17785
17786
17787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17788   void * jresult ;
17789   Dali::Handle *result = 0 ;
17790
17791   {
17792     try {
17793       result = (Dali::Handle *)new Dali::Handle();
17794     } catch (std::out_of_range& e) {
17795       {
17796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17797       };
17798     } catch (std::exception& e) {
17799       {
17800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17801       };
17802     } catch (...) {
17803       {
17804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17805       };
17806     }
17807   }
17808   jresult = (void *)result;
17809   return jresult;
17810 }
17811
17812
17813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17814   void * jresult ;
17815   Dali::Handle result;
17816
17817   {
17818     try {
17819       result = Dali::Handle::New();
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (...) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17831       };
17832     }
17833   }
17834   jresult = new Dali::Handle((const Dali::Handle &)result);
17835   return jresult;
17836 }
17837
17838
17839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17840   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17841
17842   arg1 = (Dali::Handle *)jarg1;
17843   {
17844     try {
17845       delete arg1;
17846     } catch (std::out_of_range& e) {
17847       {
17848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17849       };
17850     } catch (std::exception& e) {
17851       {
17852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17853       };
17854     } catch (...) {
17855       {
17856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17857       };
17858     }
17859   }
17860 }
17861
17862
17863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17864   void * jresult ;
17865   Dali::Handle *arg1 = 0 ;
17866   Dali::Handle *result = 0 ;
17867
17868   arg1 = (Dali::Handle *)jarg1;
17869   if (!arg1) {
17870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17871     return 0;
17872   }
17873   {
17874     try {
17875       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17876     } catch (std::out_of_range& e) {
17877       {
17878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17879       };
17880     } catch (std::exception& e) {
17881       {
17882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17883       };
17884     } catch (...) {
17885       {
17886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17887       };
17888     }
17889   }
17890   jresult = (void *)result;
17891   return jresult;
17892 }
17893
17894
17895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17896   void * jresult ;
17897   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17898   Dali::Handle *arg2 = 0 ;
17899   Dali::Handle *result = 0 ;
17900
17901   arg1 = (Dali::Handle *)jarg1;
17902   arg2 = (Dali::Handle *)jarg2;
17903   if (!arg2) {
17904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17905     return 0;
17906   }
17907   {
17908     try {
17909       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17910     } catch (std::out_of_range& e) {
17911       {
17912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (std::exception& e) {
17915       {
17916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924   jresult = (void *)result;
17925   return jresult;
17926 }
17927
17928
17929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17930   void * jresult ;
17931   Dali::BaseHandle arg1 ;
17932   Dali::BaseHandle *argp1 ;
17933   Dali::Handle result;
17934
17935   argp1 = (Dali::BaseHandle *)jarg1;
17936   if (!argp1) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17938     return 0;
17939   }
17940   arg1 = *argp1;
17941   {
17942     try {
17943       result = Dali::Handle::DownCast(arg1);
17944     } catch (std::out_of_range& e) {
17945       {
17946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (std::exception& e) {
17949       {
17950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17951       };
17952     } catch (...) {
17953       {
17954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17955       };
17956     }
17957   }
17958   jresult = new Dali::Handle((const Dali::Handle &)result);
17959   return jresult;
17960 }
17961
17962
17963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17964   unsigned int jresult ;
17965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17966   Dali::Handle::Capability arg2 ;
17967   bool result;
17968
17969   arg1 = (Dali::Handle *)jarg1;
17970   arg2 = (Dali::Handle::Capability)jarg2;
17971   {
17972     try {
17973       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17974     } catch (std::out_of_range& e) {
17975       {
17976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (std::exception& e) {
17979       {
17980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988   jresult = result;
17989   return jresult;
17990 }
17991
17992
17993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17994   unsigned int jresult ;
17995   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17996   unsigned int result;
17997
17998   arg1 = (Dali::Handle *)jarg1;
17999   {
18000     try {
18001       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18002     } catch (std::out_of_range& e) {
18003       {
18004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18005       };
18006     } catch (std::exception& e) {
18007       {
18008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (...) {
18011       {
18012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18013       };
18014     }
18015   }
18016   jresult = result;
18017   return jresult;
18018 }
18019
18020
18021 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18022   char * jresult ;
18023   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18024   Dali::Property::Index arg2 ;
18025   std::string result;
18026
18027   arg1 = (Dali::Handle *)jarg1;
18028   arg2 = (Dali::Property::Index)jarg2;
18029   {
18030     try {
18031       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18032     } catch (std::out_of_range& e) {
18033       {
18034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18035       };
18036     } catch (std::exception& e) {
18037       {
18038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (...) {
18041       {
18042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18043       };
18044     }
18045   }
18046   jresult = SWIG_csharp_string_callback((&result)->c_str());
18047   return jresult;
18048 }
18049
18050
18051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18052   int jresult ;
18053   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18054   std::string *arg2 = 0 ;
18055   Dali::Property::Index result;
18056
18057   arg1 = (Dali::Handle *)jarg1;
18058   if (!jarg2) {
18059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18060     return 0;
18061   }
18062   std::string arg2_str(jarg2);
18063   arg2 = &arg2_str;
18064   {
18065     try {
18066       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18067     } catch (std::out_of_range& e) {
18068       {
18069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18070       };
18071     } catch (std::exception& e) {
18072       {
18073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18074       };
18075     } catch (...) {
18076       {
18077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18078       };
18079     }
18080   }
18081   jresult = result;
18082
18083   //argout typemap for const std::string&
18084
18085   return jresult;
18086 }
18087
18088
18089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18090   unsigned int jresult ;
18091   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18092   Dali::Property::Index arg2 ;
18093   bool result;
18094
18095   arg1 = (Dali::Handle *)jarg1;
18096   arg2 = (Dali::Property::Index)jarg2;
18097   {
18098     try {
18099       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18100     } catch (std::out_of_range& e) {
18101       {
18102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18103       };
18104     } catch (std::exception& e) {
18105       {
18106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (...) {
18109       {
18110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18111       };
18112     }
18113   }
18114   jresult = result;
18115   return jresult;
18116 }
18117
18118
18119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18120   unsigned int jresult ;
18121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18122   Dali::Property::Index arg2 ;
18123   bool result;
18124
18125   arg1 = (Dali::Handle *)jarg1;
18126   arg2 = (Dali::Property::Index)jarg2;
18127   {
18128     try {
18129       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18130     } catch (std::out_of_range& e) {
18131       {
18132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18133       };
18134     } catch (std::exception& e) {
18135       {
18136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18137       };
18138     } catch (...) {
18139       {
18140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18141       };
18142     }
18143   }
18144   jresult = result;
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18150   unsigned int jresult ;
18151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18152   Dali::Property::Index arg2 ;
18153   bool result;
18154
18155   arg1 = (Dali::Handle *)jarg1;
18156   arg2 = (Dali::Property::Index)jarg2;
18157   {
18158     try {
18159       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (...) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18171       };
18172     }
18173   }
18174   jresult = result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18180   int jresult ;
18181   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18182   Dali::Property::Index arg2 ;
18183   Dali::Property::Type result;
18184
18185   arg1 = (Dali::Handle *)jarg1;
18186   arg2 = (Dali::Property::Index)jarg2;
18187   {
18188     try {
18189       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18190     } catch (std::out_of_range& e) {
18191       {
18192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (std::exception& e) {
18195       {
18196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (...) {
18199       {
18200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18201       };
18202     }
18203   }
18204   jresult = (int)result;
18205   return jresult;
18206 }
18207
18208
18209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18210   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18211   Dali::Property::Index arg2 ;
18212   Dali::Property::Value *arg3 = 0 ;
18213
18214   arg1 = (Dali::Handle *)jarg1;
18215   arg2 = (Dali::Property::Index)jarg2;
18216   arg3 = (Dali::Property::Value *)jarg3;
18217   if (!arg3) {
18218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18219     return ;
18220   }
18221   {
18222     try {
18223       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18224     } catch (std::out_of_range& e) {
18225       {
18226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18227       };
18228     } catch (std::exception& e) {
18229       {
18230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18231       };
18232     } catch (...) {
18233       {
18234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18235       };
18236     }
18237   }
18238 }
18239
18240
18241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18242   int jresult ;
18243   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18244   std::string *arg2 = 0 ;
18245   Dali::Property::Value *arg3 = 0 ;
18246   Dali::Property::Index result;
18247
18248   arg1 = (Dali::Handle *)jarg1;
18249   if (!jarg2) {
18250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18251     return 0;
18252   }
18253   std::string arg2_str(jarg2);
18254   arg2 = &arg2_str;
18255   arg3 = (Dali::Property::Value *)jarg3;
18256   if (!arg3) {
18257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18258     return 0;
18259   }
18260   {
18261     try {
18262       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18263     } catch (std::out_of_range& e) {
18264       {
18265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18266       };
18267     } catch (std::exception& e) {
18268       {
18269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18270       };
18271     } catch (...) {
18272       {
18273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18274       };
18275     }
18276   }
18277   jresult = result;
18278
18279   //argout typemap for const std::string&
18280
18281   return jresult;
18282 }
18283
18284
18285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18286   int jresult ;
18287   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18288   std::string *arg2 = 0 ;
18289   Dali::Property::Value *arg3 = 0 ;
18290   Dali::Property::AccessMode arg4 ;
18291   Dali::Property::Index result;
18292
18293   arg1 = (Dali::Handle *)jarg1;
18294   if (!jarg2) {
18295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18296     return 0;
18297   }
18298   std::string arg2_str(jarg2);
18299   arg2 = &arg2_str;
18300   arg3 = (Dali::Property::Value *)jarg3;
18301   if (!arg3) {
18302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18303     return 0;
18304   }
18305   arg4 = (Dali::Property::AccessMode)jarg4;
18306   {
18307     try {
18308       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18309     } catch (std::out_of_range& e) {
18310       {
18311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (std::exception& e) {
18314       {
18315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323   jresult = result;
18324
18325   //argout typemap for const std::string&
18326
18327   return jresult;
18328 }
18329
18330
18331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18332   void * jresult ;
18333   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18334   Dali::Property::Index arg2 ;
18335   Dali::Property::Value result;
18336
18337   arg1 = (Dali::Handle *)jarg1;
18338   arg2 = (Dali::Property::Index)jarg2;
18339   {
18340     try {
18341       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18342     } catch (std::out_of_range& e) {
18343       {
18344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18345       };
18346     } catch (std::exception& e) {
18347       {
18348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18349       };
18350     } catch (...) {
18351       {
18352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18353       };
18354     }
18355   }
18356   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18357   return jresult;
18358 }
18359
18360
18361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18362   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18363   Dali::Property::IndexContainer *arg2 = 0 ;
18364
18365   arg1 = (Dali::Handle *)jarg1;
18366   arg2 = (Dali::Property::IndexContainer *)jarg2;
18367   if (!arg2) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18369     return ;
18370   }
18371   {
18372     try {
18373       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18381       };
18382     } catch (...) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18385       };
18386     }
18387   }
18388 }
18389
18390
18391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18392   void * jresult ;
18393   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18394   Dali::Property::Index arg2 ;
18395   Dali::PropertyCondition *arg3 = 0 ;
18396   Dali::PropertyNotification result;
18397
18398   arg1 = (Dali::Handle *)jarg1;
18399   arg2 = (Dali::Property::Index)jarg2;
18400   arg3 = (Dali::PropertyCondition *)jarg3;
18401   if (!arg3) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (...) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18419       };
18420     }
18421   }
18422   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18423   return jresult;
18424 }
18425
18426
18427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18428   void * jresult ;
18429   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18430   Dali::Property::Index arg2 ;
18431   int arg3 ;
18432   Dali::PropertyCondition *arg4 = 0 ;
18433   Dali::PropertyNotification result;
18434
18435   arg1 = (Dali::Handle *)jarg1;
18436   arg2 = (Dali::Property::Index)jarg2;
18437   arg3 = (int)jarg3;
18438   arg4 = (Dali::PropertyCondition *)jarg4;
18439   if (!arg4) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18441     return 0;
18442   }
18443   {
18444     try {
18445       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18446     } catch (std::out_of_range& e) {
18447       {
18448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18449       };
18450     } catch (std::exception& e) {
18451       {
18452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18453       };
18454     } catch (...) {
18455       {
18456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18457       };
18458     }
18459   }
18460   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18461   return jresult;
18462 }
18463
18464
18465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18467   Dali::PropertyNotification arg2 ;
18468   Dali::PropertyNotification *argp2 ;
18469
18470   arg1 = (Dali::Handle *)jarg1;
18471   argp2 = (Dali::PropertyNotification *)jarg2;
18472   if (!argp2) {
18473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18474     return ;
18475   }
18476   arg2 = *argp2;
18477   {
18478     try {
18479       (arg1)->RemovePropertyNotification(arg2);
18480     } catch (std::out_of_range& e) {
18481       {
18482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18483       };
18484     } catch (std::exception& e) {
18485       {
18486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18487       };
18488     } catch (...) {
18489       {
18490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18491       };
18492     }
18493   }
18494 }
18495
18496
18497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18498   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18499
18500   arg1 = (Dali::Handle *)jarg1;
18501   {
18502     try {
18503       (arg1)->RemovePropertyNotifications();
18504     } catch (std::out_of_range& e) {
18505       {
18506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18507       };
18508     } catch (std::exception& e) {
18509       {
18510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18511       };
18512     } catch (...) {
18513       {
18514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18515       };
18516     }
18517   }
18518 }
18519
18520
18521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18523
18524   arg1 = (Dali::Handle *)jarg1;
18525   {
18526     try {
18527       (arg1)->RemoveConstraints();
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18535       };
18536     } catch (...) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18539       };
18540     }
18541   }
18542 }
18543
18544
18545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18546   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18547   unsigned int arg2 ;
18548
18549   arg1 = (Dali::Handle *)jarg1;
18550   arg2 = (unsigned int)jarg2;
18551   {
18552     try {
18553       (arg1)->RemoveConstraints(arg2);
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18561       };
18562     } catch (...) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18565       };
18566     }
18567   }
18568 }
18569
18570
18571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18572   int jresult ;
18573   Dali::Property::Index result;
18574
18575   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18576   jresult = result;
18577   return jresult;
18578 }
18579
18580
18581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18582   void * jresult ;
18583   Dali::Handle result;
18584
18585   {
18586     try {
18587       result = Dali::WeightObject::New();
18588     } catch (std::out_of_range& e) {
18589       {
18590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18591       };
18592     } catch (std::exception& e) {
18593       {
18594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (...) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18599       };
18600     }
18601   }
18602   jresult = new Dali::Handle((const Dali::Handle &)result);
18603   return jresult;
18604 }
18605
18606
18607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18608   void * jresult ;
18609   Dali::TypeInfo *result = 0 ;
18610
18611   {
18612     try {
18613       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18614     } catch (std::out_of_range& e) {
18615       {
18616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (std::exception& e) {
18619       {
18620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18621       };
18622     } catch (...) {
18623       {
18624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18625       };
18626     }
18627   }
18628   jresult = (void *)result;
18629   return jresult;
18630 }
18631
18632
18633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18634   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18635
18636   arg1 = (Dali::TypeInfo *)jarg1;
18637   {
18638     try {
18639       delete arg1;
18640     } catch (std::out_of_range& e) {
18641       {
18642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18643       };
18644     } catch (std::exception& e) {
18645       {
18646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18647       };
18648     } catch (...) {
18649       {
18650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18651       };
18652     }
18653   }
18654 }
18655
18656
18657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18658   void * jresult ;
18659   Dali::TypeInfo *arg1 = 0 ;
18660   Dali::TypeInfo *result = 0 ;
18661
18662   arg1 = (Dali::TypeInfo *)jarg1;
18663   if (!arg1) {
18664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18665     return 0;
18666   }
18667   {
18668     try {
18669       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18670     } catch (std::out_of_range& e) {
18671       {
18672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18673       };
18674     } catch (std::exception& e) {
18675       {
18676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (...) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18681       };
18682     }
18683   }
18684   jresult = (void *)result;
18685   return jresult;
18686 }
18687
18688
18689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18690   void * jresult ;
18691   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18692   Dali::TypeInfo *arg2 = 0 ;
18693   Dali::TypeInfo *result = 0 ;
18694
18695   arg1 = (Dali::TypeInfo *)jarg1;
18696   arg2 = (Dali::TypeInfo *)jarg2;
18697   if (!arg2) {
18698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18699     return 0;
18700   }
18701   {
18702     try {
18703       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (...) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18715       };
18716     }
18717   }
18718   jresult = (void *)result;
18719   return jresult;
18720 }
18721
18722
18723 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18724   char * jresult ;
18725   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18726   std::string *result = 0 ;
18727
18728   arg1 = (Dali::TypeInfo *)jarg1;
18729   {
18730     try {
18731       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18732     } catch (std::out_of_range& e) {
18733       {
18734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (std::exception& e) {
18737       {
18738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (...) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18743       };
18744     }
18745   }
18746   jresult = SWIG_csharp_string_callback(result->c_str());
18747   return jresult;
18748 }
18749
18750
18751 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18752   char * jresult ;
18753   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18754   std::string *result = 0 ;
18755
18756   arg1 = (Dali::TypeInfo *)jarg1;
18757   {
18758     try {
18759       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18760     } catch (std::out_of_range& e) {
18761       {
18762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (std::exception& e) {
18765       {
18766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18767       };
18768     } catch (...) {
18769       {
18770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18771       };
18772     }
18773   }
18774   jresult = SWIG_csharp_string_callback(result->c_str());
18775   return jresult;
18776 }
18777
18778
18779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18780   void * jresult ;
18781   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18782   Dali::BaseHandle result;
18783
18784   arg1 = (Dali::TypeInfo *)jarg1;
18785   {
18786     try {
18787       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18788     } catch (std::out_of_range& e) {
18789       {
18790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18791       };
18792     } catch (std::exception& e) {
18793       {
18794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18795       };
18796     } catch (...) {
18797       {
18798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18799       };
18800     }
18801   }
18802   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18803   return jresult;
18804 }
18805
18806
18807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18808   unsigned long jresult ;
18809   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18810   size_t result;
18811
18812   arg1 = (Dali::TypeInfo *)jarg1;
18813   {
18814     try {
18815       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18816     } catch (std::out_of_range& e) {
18817       {
18818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (std::exception& e) {
18821       {
18822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (...) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18827       };
18828     }
18829   }
18830   jresult = (unsigned long)result;
18831   return jresult;
18832 }
18833
18834
18835 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18836   char * jresult ;
18837   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18838   size_t arg2 ;
18839   std::string result;
18840
18841   arg1 = (Dali::TypeInfo *)jarg1;
18842   arg2 = (size_t)jarg2;
18843   {
18844     try {
18845       result = (arg1)->GetActionName(arg2);
18846     } catch (std::out_of_range& e) {
18847       {
18848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (std::exception& e) {
18851       {
18852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18853       };
18854     } catch (...) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18857       };
18858     }
18859   }
18860   jresult = SWIG_csharp_string_callback((&result)->c_str());
18861   return jresult;
18862 }
18863
18864
18865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18866   unsigned long jresult ;
18867   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18868   size_t result;
18869
18870   arg1 = (Dali::TypeInfo *)jarg1;
18871   {
18872     try {
18873       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18874     } catch (std::out_of_range& e) {
18875       {
18876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18877       };
18878     } catch (std::exception& e) {
18879       {
18880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18881       };
18882     } catch (...) {
18883       {
18884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18885       };
18886     }
18887   }
18888   jresult = (unsigned long)result;
18889   return jresult;
18890 }
18891
18892
18893 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18894   char * jresult ;
18895   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18896   size_t arg2 ;
18897   std::string result;
18898
18899   arg1 = (Dali::TypeInfo *)jarg1;
18900   arg2 = (size_t)jarg2;
18901   {
18902     try {
18903       result = (arg1)->GetSignalName(arg2);
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18911       };
18912     } catch (...) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18915       };
18916     }
18917   }
18918   jresult = SWIG_csharp_string_callback((&result)->c_str());
18919   return jresult;
18920 }
18921
18922
18923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18924   unsigned long jresult ;
18925   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18926   size_t result;
18927
18928   arg1 = (Dali::TypeInfo *)jarg1;
18929   {
18930     try {
18931       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18932     } catch (std::out_of_range& e) {
18933       {
18934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18935       };
18936     } catch (std::exception& e) {
18937       {
18938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18939       };
18940     } catch (...) {
18941       {
18942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18943       };
18944     }
18945   }
18946   jresult = (unsigned long)result;
18947   return jresult;
18948 }
18949
18950
18951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18952   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18953   Dali::Property::IndexContainer *arg2 = 0 ;
18954
18955   arg1 = (Dali::TypeInfo *)jarg1;
18956   arg2 = (Dali::Property::IndexContainer *)jarg2;
18957   if (!arg2) {
18958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18959     return ;
18960   }
18961   {
18962     try {
18963       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18964     } catch (std::out_of_range& e) {
18965       {
18966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18967       };
18968     } catch (std::exception& e) {
18969       {
18970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18971       };
18972     } catch (...) {
18973       {
18974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18975       };
18976     }
18977   }
18978 }
18979
18980
18981 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18982   char * jresult ;
18983   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18984   Dali::Property::Index arg2 ;
18985   std::string *result = 0 ;
18986
18987   arg1 = (Dali::TypeInfo *)jarg1;
18988   arg2 = (Dali::Property::Index)jarg2;
18989   {
18990     try {
18991       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18999       };
19000     } catch (...) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19003       };
19004     }
19005   }
19006   jresult = SWIG_csharp_string_callback(result->c_str());
19007   return jresult;
19008 }
19009
19010
19011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19012   void * jresult ;
19013   Dali::TypeRegistry result;
19014
19015   {
19016     try {
19017       result = Dali::TypeRegistry::Get();
19018     } catch (std::out_of_range& e) {
19019       {
19020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19021       };
19022     } catch (std::exception& e) {
19023       {
19024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19025       };
19026     } catch (...) {
19027       {
19028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19029       };
19030     }
19031   }
19032   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19033   return jresult;
19034 }
19035
19036
19037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19038   void * jresult ;
19039   Dali::TypeRegistry *result = 0 ;
19040
19041   {
19042     try {
19043       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19044     } catch (std::out_of_range& e) {
19045       {
19046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (std::exception& e) {
19049       {
19050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19051       };
19052     } catch (...) {
19053       {
19054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19055       };
19056     }
19057   }
19058   jresult = (void *)result;
19059   return jresult;
19060 }
19061
19062
19063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19064   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19065
19066   arg1 = (Dali::TypeRegistry *)jarg1;
19067   {
19068     try {
19069       delete arg1;
19070     } catch (std::out_of_range& e) {
19071       {
19072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (std::exception& e) {
19075       {
19076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084 }
19085
19086
19087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19088   void * jresult ;
19089   Dali::TypeRegistry *arg1 = 0 ;
19090   Dali::TypeRegistry *result = 0 ;
19091
19092   arg1 = (Dali::TypeRegistry *)jarg1;
19093   if (!arg1) {
19094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19095     return 0;
19096   }
19097   {
19098     try {
19099       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19100     } catch (std::out_of_range& e) {
19101       {
19102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19103       };
19104     } catch (std::exception& e) {
19105       {
19106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19111       };
19112     }
19113   }
19114   jresult = (void *)result;
19115   return jresult;
19116 }
19117
19118
19119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19120   void * jresult ;
19121   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19122   Dali::TypeRegistry *arg2 = 0 ;
19123   Dali::TypeRegistry *result = 0 ;
19124
19125   arg1 = (Dali::TypeRegistry *)jarg1;
19126   arg2 = (Dali::TypeRegistry *)jarg2;
19127   if (!arg2) {
19128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19129     return 0;
19130   }
19131   {
19132     try {
19133       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19134     } catch (std::out_of_range& e) {
19135       {
19136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19137       };
19138     } catch (std::exception& e) {
19139       {
19140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19145       };
19146     }
19147   }
19148   jresult = (void *)result;
19149   return jresult;
19150 }
19151
19152
19153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19154   void * jresult ;
19155   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19156   std::string *arg2 = 0 ;
19157   Dali::TypeInfo result;
19158
19159   arg1 = (Dali::TypeRegistry *)jarg1;
19160   if (!jarg2) {
19161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19162     return 0;
19163   }
19164   std::string arg2_str(jarg2);
19165   arg2 = &arg2_str;
19166   {
19167     try {
19168       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19169     } catch (std::out_of_range& e) {
19170       {
19171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19172       };
19173     } catch (std::exception& e) {
19174       {
19175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19176       };
19177     } catch (...) {
19178       {
19179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19180       };
19181     }
19182   }
19183   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19184
19185   //argout typemap for const std::string&
19186
19187   return jresult;
19188 }
19189
19190
19191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19192   void * jresult ;
19193   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19194   std::type_info *arg2 = 0 ;
19195   Dali::TypeInfo result;
19196
19197   arg1 = (Dali::TypeRegistry *)jarg1;
19198   arg2 = (std::type_info *)jarg2;
19199   if (!arg2) {
19200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19201     return 0;
19202   }
19203   {
19204     try {
19205       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19206     } catch (std::out_of_range& e) {
19207       {
19208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19209       };
19210     } catch (std::exception& e) {
19211       {
19212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19213       };
19214     } catch (...) {
19215       {
19216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19217       };
19218     }
19219   }
19220   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19221   return jresult;
19222 }
19223
19224
19225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19226   unsigned long jresult ;
19227   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19228   size_t result;
19229
19230   arg1 = (Dali::TypeRegistry *)jarg1;
19231   {
19232     try {
19233       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19234     } catch (std::out_of_range& e) {
19235       {
19236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19237       };
19238     } catch (std::exception& e) {
19239       {
19240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19241       };
19242     } catch (...) {
19243       {
19244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19245       };
19246     }
19247   }
19248   jresult = (unsigned long)result;
19249   return jresult;
19250 }
19251
19252
19253 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19254   char * jresult ;
19255   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19256   size_t arg2 ;
19257   std::string result;
19258
19259   arg1 = (Dali::TypeRegistry *)jarg1;
19260   arg2 = (size_t)jarg2;
19261   {
19262     try {
19263       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19264     } catch (std::out_of_range& e) {
19265       {
19266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (std::exception& e) {
19269       {
19270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278   jresult = SWIG_csharp_string_callback((&result)->c_str());
19279   return jresult;
19280 }
19281
19282
19283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19284   void * jresult ;
19285   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19286   Dali::TypeRegistry *result = 0 ;
19287
19288   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19289   {
19290     try {
19291       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19292     } catch (std::out_of_range& e) {
19293       {
19294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19295       };
19296     } catch (std::exception& e) {
19297       {
19298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (...) {
19301       {
19302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19303       };
19304     }
19305   }
19306   jresult = (void *)result;
19307   return jresult;
19308 }
19309
19310
19311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19312   void * jresult ;
19313   std::type_info *arg1 = 0 ;
19314   std::type_info *arg2 = 0 ;
19315   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19316   Dali::TypeRegistration *result = 0 ;
19317
19318   arg1 = (std::type_info *)jarg1;
19319   if (!arg1) {
19320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19321     return 0;
19322   }
19323   arg2 = (std::type_info *)jarg2;
19324   if (!arg2) {
19325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19326     return 0;
19327   }
19328   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19329   {
19330     try {
19331       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (...) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19343       };
19344     }
19345   }
19346   jresult = (void *)result;
19347   return jresult;
19348 }
19349
19350
19351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19352   void * jresult ;
19353   std::type_info *arg1 = 0 ;
19354   std::type_info *arg2 = 0 ;
19355   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19356   bool arg4 ;
19357   Dali::TypeRegistration *result = 0 ;
19358
19359   arg1 = (std::type_info *)jarg1;
19360   if (!arg1) {
19361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19362     return 0;
19363   }
19364   arg2 = (std::type_info *)jarg2;
19365   if (!arg2) {
19366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19367     return 0;
19368   }
19369   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19370   arg4 = jarg4 ? true : false;
19371   {
19372     try {
19373       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19374     } catch (std::out_of_range& e) {
19375       {
19376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19377       };
19378     } catch (std::exception& e) {
19379       {
19380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19381       };
19382     } catch (...) {
19383       {
19384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19385       };
19386     }
19387   }
19388   jresult = (void *)result;
19389   return jresult;
19390 }
19391
19392
19393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19394   void * jresult ;
19395   std::string *arg1 = 0 ;
19396   std::type_info *arg2 = 0 ;
19397   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19398   Dali::TypeRegistration *result = 0 ;
19399
19400   if (!jarg1) {
19401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19402     return 0;
19403   }
19404   std::string arg1_str(jarg1);
19405   arg1 = &arg1_str;
19406   arg2 = (std::type_info *)jarg2;
19407   if (!arg2) {
19408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19409     return 0;
19410   }
19411   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19412   {
19413     try {
19414       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19415     } catch (std::out_of_range& e) {
19416       {
19417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19418       };
19419     } catch (std::exception& e) {
19420       {
19421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19422       };
19423     } catch (...) {
19424       {
19425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19426       };
19427     }
19428   }
19429   jresult = (void *)result;
19430
19431   //argout typemap for const std::string&
19432
19433   return jresult;
19434 }
19435
19436
19437 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19438   char * jresult ;
19439   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19440   std::string result;
19441
19442   arg1 = (Dali::TypeRegistration *)jarg1;
19443   {
19444     try {
19445       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19446     } catch (std::out_of_range& e) {
19447       {
19448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19449       };
19450     } catch (std::exception& e) {
19451       {
19452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19453       };
19454     } catch (...) {
19455       {
19456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19457       };
19458     }
19459   }
19460   jresult = SWIG_csharp_string_callback((&result)->c_str());
19461   return jresult;
19462 }
19463
19464
19465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19466   std::string *arg1 = 0 ;
19467   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19468
19469   if (!jarg1) {
19470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19471     return ;
19472   }
19473   std::string arg1_str(jarg1);
19474   arg1 = &arg1_str;
19475   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19476   {
19477     try {
19478       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19479     } catch (std::out_of_range& e) {
19480       {
19481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19482       };
19483     } catch (std::exception& e) {
19484       {
19485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19486       };
19487     } catch (...) {
19488       {
19489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19490       };
19491     }
19492   }
19493
19494   //argout typemap for const std::string&
19495
19496 }
19497
19498
19499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19500   std::string *arg1 = 0 ;
19501   std::string *arg2 = 0 ;
19502   int arg3 ;
19503   Dali::Property::Type arg4 ;
19504   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19505   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19506
19507   if (!jarg1) {
19508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19509     return ;
19510   }
19511   std::string arg1_str(jarg1);
19512   arg1 = &arg1_str;
19513   if (!jarg2) {
19514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19515     return ;
19516   }
19517   std::string arg2_str(jarg2);
19518   arg2 = &arg2_str;
19519   arg3 = (int)jarg3;
19520   arg4 = (Dali::Property::Type)jarg4;
19521   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19522   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19523   {
19524     try {
19525       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19526     } catch (std::out_of_range& e) {
19527       {
19528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19529       };
19530     } catch (std::exception& e) {
19531       {
19532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19533       };
19534     } catch (...) {
19535       {
19536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19537       };
19538     }
19539   }
19540
19541   //argout typemap for const std::string&
19542
19543
19544   //argout typemap for const std::string&
19545
19546 }
19547
19548
19549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19550   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19551
19552   arg1 = (Dali::TypeRegistration *)jarg1;
19553   {
19554     try {
19555       delete arg1;
19556     } catch (std::out_of_range& e) {
19557       {
19558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19559       };
19560     } catch (std::exception& e) {
19561       {
19562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19567       };
19568     }
19569   }
19570 }
19571
19572
19573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19574   void * jresult ;
19575   Dali::TypeRegistration *arg1 = 0 ;
19576   std::string *arg2 = 0 ;
19577   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19578   Dali::SignalConnectorType *result = 0 ;
19579
19580   arg1 = (Dali::TypeRegistration *)jarg1;
19581   if (!arg1) {
19582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19583     return 0;
19584   }
19585   if (!jarg2) {
19586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19587     return 0;
19588   }
19589   std::string arg2_str(jarg2);
19590   arg2 = &arg2_str;
19591   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19592   {
19593     try {
19594       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19595     } catch (std::out_of_range& e) {
19596       {
19597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19598       };
19599     } catch (std::exception& e) {
19600       {
19601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19602       };
19603     } catch (...) {
19604       {
19605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19606       };
19607     }
19608   }
19609   jresult = (void *)result;
19610
19611   //argout typemap for const std::string&
19612
19613   return jresult;
19614 }
19615
19616
19617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19618   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19619
19620   arg1 = (Dali::SignalConnectorType *)jarg1;
19621   {
19622     try {
19623       delete arg1;
19624     } catch (std::out_of_range& e) {
19625       {
19626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19627       };
19628     } catch (std::exception& e) {
19629       {
19630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19631       };
19632     } catch (...) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19635       };
19636     }
19637   }
19638 }
19639
19640
19641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19642   void * jresult ;
19643   Dali::TypeRegistration *arg1 = 0 ;
19644   std::string *arg2 = 0 ;
19645   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19646   Dali::TypeAction *result = 0 ;
19647
19648   arg1 = (Dali::TypeRegistration *)jarg1;
19649   if (!arg1) {
19650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19651     return 0;
19652   }
19653   if (!jarg2) {
19654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19655     return 0;
19656   }
19657   std::string arg2_str(jarg2);
19658   arg2 = &arg2_str;
19659   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19660   {
19661     try {
19662       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19663     } catch (std::out_of_range& e) {
19664       {
19665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (std::exception& e) {
19668       {
19669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677   jresult = (void *)result;
19678
19679   //argout typemap for const std::string&
19680
19681   return jresult;
19682 }
19683
19684
19685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19686   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19687
19688   arg1 = (Dali::TypeAction *)jarg1;
19689   {
19690     try {
19691       delete arg1;
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19699       };
19700     } catch (...) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19703       };
19704     }
19705   }
19706 }
19707
19708
19709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19710   void * jresult ;
19711   Dali::TypeRegistration *arg1 = 0 ;
19712   std::string *arg2 = 0 ;
19713   Dali::Property::Index arg3 ;
19714   Dali::Property::Type arg4 ;
19715   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19716   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19717   Dali::PropertyRegistration *result = 0 ;
19718
19719   arg1 = (Dali::TypeRegistration *)jarg1;
19720   if (!arg1) {
19721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19722     return 0;
19723   }
19724   if (!jarg2) {
19725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19726     return 0;
19727   }
19728   std::string arg2_str(jarg2);
19729   arg2 = &arg2_str;
19730   arg3 = (Dali::Property::Index)jarg3;
19731   arg4 = (Dali::Property::Type)jarg4;
19732   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19733   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19734   {
19735     try {
19736       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19737     } catch (std::out_of_range& e) {
19738       {
19739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19740       };
19741     } catch (std::exception& e) {
19742       {
19743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19744       };
19745     } catch (...) {
19746       {
19747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19748       };
19749     }
19750   }
19751   jresult = (void *)result;
19752
19753   //argout typemap for const std::string&
19754
19755   return jresult;
19756 }
19757
19758
19759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19760   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19761
19762   arg1 = (Dali::PropertyRegistration *)jarg1;
19763   {
19764     try {
19765       delete arg1;
19766     } catch (std::out_of_range& e) {
19767       {
19768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19769       };
19770     } catch (std::exception& e) {
19771       {
19772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19773       };
19774     } catch (...) {
19775       {
19776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19777       };
19778     }
19779   }
19780 }
19781
19782
19783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19784   void * jresult ;
19785   Dali::TypeRegistration *arg1 = 0 ;
19786   std::string *arg2 = 0 ;
19787   Dali::Property::Index arg3 ;
19788   Dali::Property::Type arg4 ;
19789   Dali::AnimatablePropertyRegistration *result = 0 ;
19790
19791   arg1 = (Dali::TypeRegistration *)jarg1;
19792   if (!arg1) {
19793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19794     return 0;
19795   }
19796   if (!jarg2) {
19797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19798     return 0;
19799   }
19800   std::string arg2_str(jarg2);
19801   arg2 = &arg2_str;
19802   arg3 = (Dali::Property::Index)jarg3;
19803   arg4 = (Dali::Property::Type)jarg4;
19804   {
19805     try {
19806       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19807     } catch (std::out_of_range& e) {
19808       {
19809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19810       };
19811     } catch (std::exception& e) {
19812       {
19813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19814       };
19815     } catch (...) {
19816       {
19817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19818       };
19819     }
19820   }
19821   jresult = (void *)result;
19822
19823   //argout typemap for const std::string&
19824
19825   return jresult;
19826 }
19827
19828
19829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19830   void * jresult ;
19831   Dali::TypeRegistration *arg1 = 0 ;
19832   std::string *arg2 = 0 ;
19833   Dali::Property::Index arg3 ;
19834   Dali::Property::Value *arg4 = 0 ;
19835   Dali::AnimatablePropertyRegistration *result = 0 ;
19836
19837   arg1 = (Dali::TypeRegistration *)jarg1;
19838   if (!arg1) {
19839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19840     return 0;
19841   }
19842   if (!jarg2) {
19843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19844     return 0;
19845   }
19846   std::string arg2_str(jarg2);
19847   arg2 = &arg2_str;
19848   arg3 = (Dali::Property::Index)jarg3;
19849   arg4 = (Dali::Property::Value *)jarg4;
19850   if (!arg4) {
19851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19852     return 0;
19853   }
19854   {
19855     try {
19856       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19857     } catch (std::out_of_range& e) {
19858       {
19859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19860       };
19861     } catch (std::exception& e) {
19862       {
19863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19864       };
19865     } catch (...) {
19866       {
19867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19868       };
19869     }
19870   }
19871   jresult = (void *)result;
19872
19873   //argout typemap for const std::string&
19874
19875   return jresult;
19876 }
19877
19878
19879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19880   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19881
19882   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19883   {
19884     try {
19885       delete arg1;
19886     } catch (std::out_of_range& e) {
19887       {
19888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19889       };
19890     } catch (std::exception& e) {
19891       {
19892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19893       };
19894     } catch (...) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19897       };
19898     }
19899   }
19900 }
19901
19902
19903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19904   void * jresult ;
19905   Dali::TypeRegistration *arg1 = 0 ;
19906   std::string *arg2 = 0 ;
19907   Dali::Property::Index arg3 ;
19908   Dali::Property::Index arg4 ;
19909   unsigned int arg5 ;
19910   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19911
19912   arg1 = (Dali::TypeRegistration *)jarg1;
19913   if (!arg1) {
19914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19915     return 0;
19916   }
19917   if (!jarg2) {
19918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19919     return 0;
19920   }
19921   std::string arg2_str(jarg2);
19922   arg2 = &arg2_str;
19923   arg3 = (Dali::Property::Index)jarg3;
19924   arg4 = (Dali::Property::Index)jarg4;
19925   arg5 = (unsigned int)jarg5;
19926   {
19927     try {
19928       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19929     } catch (std::out_of_range& e) {
19930       {
19931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19932       };
19933     } catch (std::exception& e) {
19934       {
19935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (...) {
19938       {
19939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19940       };
19941     }
19942   }
19943   jresult = (void *)result;
19944
19945   //argout typemap for const std::string&
19946
19947   return jresult;
19948 }
19949
19950
19951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19952   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19953
19954   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19955   {
19956     try {
19957       delete arg1;
19958     } catch (std::out_of_range& e) {
19959       {
19960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19961       };
19962     } catch (std::exception& e) {
19963       {
19964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19965       };
19966     } catch (...) {
19967       {
19968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19969       };
19970     }
19971   }
19972 }
19973
19974
19975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19976   void * jresult ;
19977   Dali::TypeRegistration *arg1 = 0 ;
19978   std::string *arg2 = 0 ;
19979   Dali::Property::Index arg3 ;
19980   Dali::Property::Type arg4 ;
19981   Dali::ChildPropertyRegistration *result = 0 ;
19982
19983   arg1 = (Dali::TypeRegistration *)jarg1;
19984   if (!arg1) {
19985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19986     return 0;
19987   }
19988   if (!jarg2) {
19989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19990     return 0;
19991   }
19992   std::string arg2_str(jarg2);
19993   arg2 = &arg2_str;
19994   arg3 = (Dali::Property::Index)jarg3;
19995   arg4 = (Dali::Property::Type)jarg4;
19996   {
19997     try {
19998       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19999     } catch (std::out_of_range& e) {
20000       {
20001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20002       };
20003     } catch (std::exception& e) {
20004       {
20005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20006       };
20007     } catch (...) {
20008       {
20009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20010       };
20011     }
20012   }
20013   jresult = (void *)result;
20014
20015   //argout typemap for const std::string&
20016
20017   return jresult;
20018 }
20019
20020
20021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20022   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20023
20024   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20025   {
20026     try {
20027       delete arg1;
20028     } catch (std::out_of_range& e) {
20029       {
20030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20031       };
20032     } catch (std::exception& e) {
20033       {
20034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20035       };
20036     } catch (...) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20039       };
20040     }
20041   }
20042 }
20043
20044
20045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20046   unsigned int jresult ;
20047   std::string *arg1 = 0 ;
20048   std::type_info *arg2 = 0 ;
20049   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20050   bool result;
20051
20052   if (!jarg1) {
20053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20054     return 0;
20055   }
20056   std::string arg1_str(jarg1);
20057   arg1 = &arg1_str;
20058   arg2 = (std::type_info *)jarg2;
20059   if (!arg2) {
20060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20061     return 0;
20062   }
20063   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20064   {
20065     try {
20066       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20067     } catch (std::out_of_range& e) {
20068       {
20069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20070       };
20071     } catch (std::exception& e) {
20072       {
20073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (...) {
20076       {
20077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20078       };
20079     }
20080   }
20081   jresult = result;
20082
20083   //argout typemap for const std::string&
20084
20085   return jresult;
20086 }
20087
20088
20089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20090   unsigned int jresult ;
20091   std::string *arg1 = 0 ;
20092   std::string *arg2 = 0 ;
20093   Dali::Property::Index arg3 ;
20094   Dali::Property::Type arg4 ;
20095   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20096   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20097   bool result;
20098
20099   if (!jarg1) {
20100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20101     return 0;
20102   }
20103   std::string arg1_str(jarg1);
20104   arg1 = &arg1_str;
20105   if (!jarg2) {
20106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20107     return 0;
20108   }
20109   std::string arg2_str(jarg2);
20110   arg2 = &arg2_str;
20111   arg3 = (Dali::Property::Index)jarg3;
20112   arg4 = (Dali::Property::Type)jarg4;
20113   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20114   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20115   {
20116     try {
20117       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20118     } catch (std::out_of_range& e) {
20119       {
20120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20121       };
20122     } catch (std::exception& e) {
20123       {
20124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20125       };
20126     } catch (...) {
20127       {
20128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20129       };
20130     }
20131   }
20132   jresult = result;
20133
20134   //argout typemap for const std::string&
20135
20136
20137   //argout typemap for const std::string&
20138
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20144   float jresult ;
20145   float result;
20146
20147   result = (float)(float)Dali::ParentOrigin::TOP;
20148   jresult = result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20154   float jresult ;
20155   float result;
20156
20157   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20158   jresult = result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20164   float jresult ;
20165   float result;
20166
20167   result = (float)(float)Dali::ParentOrigin::LEFT;
20168   jresult = result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20174   float jresult ;
20175   float result;
20176
20177   result = (float)(float)Dali::ParentOrigin::RIGHT;
20178   jresult = result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20184   float jresult ;
20185   float result;
20186
20187   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20204   void * jresult ;
20205   Dali::Vector3 *result = 0 ;
20206
20207   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20224   void * jresult ;
20225   Dali::Vector3 *result = 0 ;
20226
20227   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20234   void * jresult ;
20235   Dali::Vector3 *result = 0 ;
20236
20237   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20238   jresult = (void *)result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20244   void * jresult ;
20245   Dali::Vector3 *result = 0 ;
20246
20247   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20264   void * jresult ;
20265   Dali::Vector3 *result = 0 ;
20266
20267   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20284   float jresult ;
20285   float result;
20286
20287   result = (float)(float)Dali::AnchorPoint::TOP;
20288   jresult = result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20294   float jresult ;
20295   float result;
20296
20297   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20298   jresult = result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20304   float jresult ;
20305   float result;
20306
20307   result = (float)(float)Dali::AnchorPoint::LEFT;
20308   jresult = result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20314   float jresult ;
20315   float result;
20316
20317   result = (float)(float)Dali::AnchorPoint::RIGHT;
20318   jresult = result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20324   float jresult ;
20325   float result;
20326
20327   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20328   jresult = result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20344   void * jresult ;
20345   Dali::Vector3 *result = 0 ;
20346
20347   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20354   void * jresult ;
20355   Dali::Vector3 *result = 0 ;
20356
20357   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20364   void * jresult ;
20365   Dali::Vector3 *result = 0 ;
20366
20367   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20374   void * jresult ;
20375   Dali::Vector3 *result = 0 ;
20376
20377   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20384   void * jresult ;
20385   Dali::Vector3 *result = 0 ;
20386
20387   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20394   void * jresult ;
20395   Dali::Vector3 *result = 0 ;
20396
20397   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20404   void * jresult ;
20405   Dali::Vector3 *result = 0 ;
20406
20407   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20414   void * jresult ;
20415   Dali::Vector3 *result = 0 ;
20416
20417   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20424   void * jresult ;
20425   Dali::Vector4 *result = 0 ;
20426
20427   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20434   void * jresult ;
20435   Dali::Vector4 *result = 0 ;
20436
20437   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20444   void * jresult ;
20445   Dali::Vector4 *result = 0 ;
20446
20447   result = (Dali::Vector4 *)&Dali::Color::RED;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20454   void * jresult ;
20455   Dali::Vector4 *result = 0 ;
20456
20457   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20458   jresult = (void *)result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20464   void * jresult ;
20465   Dali::Vector4 *result = 0 ;
20466
20467   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20468   jresult = (void *)result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20474   void * jresult ;
20475   Dali::Vector4 *result = 0 ;
20476
20477   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20478   jresult = (void *)result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20484   void * jresult ;
20485   Dali::Vector4 *result = 0 ;
20486
20487   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20488   jresult = (void *)result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20494   void * jresult ;
20495   Dali::Vector4 *result = 0 ;
20496
20497   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20498   jresult = (void *)result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20504   void * jresult ;
20505   Dali::Vector4 *result = 0 ;
20506
20507   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20508   jresult = (void *)result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20514   float jresult ;
20515   float result;
20516
20517   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20524   float jresult ;
20525   float result;
20526
20527   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20528   jresult = result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20544   float jresult ;
20545   float result;
20546
20547   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20554   float jresult ;
20555   float result;
20556
20557   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20558   jresult = result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20564   float jresult ;
20565   float result;
20566
20567   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20568   jresult = result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20574   float jresult ;
20575   float result;
20576
20577   result = (float)(float)Dali::Math::PI;
20578   jresult = result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20584   float jresult ;
20585   float result;
20586
20587   result = (float)(float)Dali::Math::PI_2;
20588   jresult = result;
20589   return jresult;
20590 }
20591
20592
20593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20594   float jresult ;
20595   float result;
20596
20597   result = (float)(float)Dali::Math::PI_4;
20598   jresult = result;
20599   return jresult;
20600 }
20601
20602
20603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20604   float jresult ;
20605   float result;
20606
20607   result = (float)(float)Dali::Math::PI_OVER_180;
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20614   float jresult ;
20615   float result;
20616
20617   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20618   jresult = result;
20619   return jresult;
20620 }
20621
20622
20623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20624   int jresult ;
20625   Dali::ResizePolicy::Type result;
20626
20627   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20628   jresult = (int)result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20634   unsigned long jresult ;
20635   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20636   Dali::VectorBase::SizeType result;
20637
20638   arg1 = (Dali::VectorBase *)jarg1;
20639   {
20640     try {
20641       result = ((Dali::VectorBase const *)arg1)->Count();
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (...) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20653       };
20654     }
20655   }
20656   jresult = (unsigned long)result;
20657   return jresult;
20658 }
20659
20660
20661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20662   unsigned long jresult ;
20663   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20664   Dali::VectorBase::SizeType result;
20665
20666   arg1 = (Dali::VectorBase *)jarg1;
20667   {
20668     try {
20669       result = ((Dali::VectorBase const *)arg1)->Size();
20670     } catch (std::out_of_range& e) {
20671       {
20672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20673       };
20674     } catch (std::exception& e) {
20675       {
20676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20677       };
20678     } catch (...) {
20679       {
20680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20681       };
20682     }
20683   }
20684   jresult = (unsigned long)result;
20685   return jresult;
20686 }
20687
20688
20689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20690   unsigned int jresult ;
20691   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20692   bool result;
20693
20694   arg1 = (Dali::VectorBase *)jarg1;
20695   {
20696     try {
20697       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712   jresult = result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20718   unsigned long jresult ;
20719   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20720   Dali::VectorBase::SizeType result;
20721
20722   arg1 = (Dali::VectorBase *)jarg1;
20723   {
20724     try {
20725       result = ((Dali::VectorBase const *)arg1)->Capacity();
20726     } catch (std::out_of_range& e) {
20727       {
20728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20729       };
20730     } catch (std::exception& e) {
20731       {
20732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (...) {
20735       {
20736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20737       };
20738     }
20739   }
20740   jresult = (unsigned long)result;
20741   return jresult;
20742 }
20743
20744
20745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20746   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20747
20748   arg1 = (Dali::VectorBase *)jarg1;
20749   {
20750     try {
20751       (arg1)->Release();
20752     } catch (std::out_of_range& e) {
20753       {
20754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20755       };
20756     } catch (std::exception& e) {
20757       {
20758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20759       };
20760     } catch (...) {
20761       {
20762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20763       };
20764     }
20765   }
20766 }
20767
20768
20769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20770   void * jresult ;
20771   Dali::Image *result = 0 ;
20772
20773   {
20774     try {
20775       result = (Dali::Image *)new Dali::Image();
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (...) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20787       };
20788     }
20789   }
20790   jresult = (void *)result;
20791   return jresult;
20792 }
20793
20794
20795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20796   Dali::Image *arg1 = (Dali::Image *) 0 ;
20797
20798   arg1 = (Dali::Image *)jarg1;
20799   {
20800     try {
20801       delete arg1;
20802     } catch (std::out_of_range& e) {
20803       {
20804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20805       };
20806     } catch (std::exception& e) {
20807       {
20808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20809       };
20810     } catch (...) {
20811       {
20812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20813       };
20814     }
20815   }
20816 }
20817
20818
20819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20820   void * jresult ;
20821   Dali::Image *arg1 = 0 ;
20822   Dali::Image *result = 0 ;
20823
20824   arg1 = (Dali::Image *)jarg1;
20825   if (!arg1) {
20826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20827     return 0;
20828   }
20829   {
20830     try {
20831       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20832     } catch (std::out_of_range& e) {
20833       {
20834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (std::exception& e) {
20837       {
20838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846   jresult = (void *)result;
20847   return jresult;
20848 }
20849
20850
20851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20852   void * jresult ;
20853   Dali::Image *arg1 = (Dali::Image *) 0 ;
20854   Dali::Image *arg2 = 0 ;
20855   Dali::Image *result = 0 ;
20856
20857   arg1 = (Dali::Image *)jarg1;
20858   arg2 = (Dali::Image *)jarg2;
20859   if (!arg2) {
20860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20861     return 0;
20862   }
20863   {
20864     try {
20865       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (...) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20877       };
20878     }
20879   }
20880   jresult = (void *)result;
20881   return jresult;
20882 }
20883
20884
20885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20886   void * jresult ;
20887   Dali::BaseHandle arg1 ;
20888   Dali::BaseHandle *argp1 ;
20889   Dali::Image result;
20890
20891   argp1 = (Dali::BaseHandle *)jarg1;
20892   if (!argp1) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20894     return 0;
20895   }
20896   arg1 = *argp1;
20897   {
20898     try {
20899       result = Dali::Image::DownCast(arg1);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20907       };
20908     } catch (...) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20911       };
20912     }
20913   }
20914   jresult = new Dali::Image((const Dali::Image &)result);
20915   return jresult;
20916 }
20917
20918
20919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20920   unsigned int jresult ;
20921   Dali::Image *arg1 = (Dali::Image *) 0 ;
20922   unsigned int result;
20923
20924   arg1 = (Dali::Image *)jarg1;
20925   {
20926     try {
20927       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20928     } catch (std::out_of_range& e) {
20929       {
20930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20931       };
20932     } catch (std::exception& e) {
20933       {
20934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20935       };
20936     } catch (...) {
20937       {
20938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20939       };
20940     }
20941   }
20942   jresult = result;
20943   return jresult;
20944 }
20945
20946
20947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20948   unsigned int jresult ;
20949   Dali::Image *arg1 = (Dali::Image *) 0 ;
20950   unsigned int result;
20951
20952   arg1 = (Dali::Image *)jarg1;
20953   {
20954     try {
20955       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20956     } catch (std::out_of_range& e) {
20957       {
20958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20959       };
20960     } catch (std::exception& e) {
20961       {
20962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20963       };
20964     } catch (...) {
20965       {
20966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20967       };
20968     }
20969   }
20970   jresult = result;
20971   return jresult;
20972 }
20973
20974
20975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20976   void * jresult ;
20977   Dali::Image *arg1 = (Dali::Image *) 0 ;
20978   Dali::Image::ImageSignalType *result = 0 ;
20979
20980   arg1 = (Dali::Image *)jarg1;
20981   {
20982     try {
20983       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (...) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20995       };
20996     }
20997   }
20998   jresult = (void *)result;
20999   return jresult;
21000 }
21001
21002
21003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21004   int jresult ;
21005   Dali::Pixel::Format result;
21006
21007   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21008   jresult = (int)result;
21009   return jresult;
21010 }
21011
21012
21013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21014   int jresult ;
21015   Dali::Pixel::Format result;
21016
21017   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21018   jresult = (int)result;
21019   return jresult;
21020 }
21021
21022
21023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21024   unsigned int jresult ;
21025   Dali::Pixel::Format arg1 ;
21026   bool result;
21027
21028   arg1 = (Dali::Pixel::Format)jarg1;
21029   {
21030     try {
21031       result = (bool)Dali::Pixel::HasAlpha(arg1);
21032     } catch (std::out_of_range& e) {
21033       {
21034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21035       };
21036     } catch (std::exception& e) {
21037       {
21038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21039       };
21040     } catch (...) {
21041       {
21042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21043       };
21044     }
21045   }
21046   jresult = result;
21047   return jresult;
21048 }
21049
21050
21051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21052   unsigned int jresult ;
21053   Dali::Pixel::Format arg1 ;
21054   unsigned int result;
21055
21056   arg1 = (Dali::Pixel::Format)jarg1;
21057   {
21058     try {
21059       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21060     } catch (std::out_of_range& e) {
21061       {
21062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (std::exception& e) {
21065       {
21066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21067       };
21068     } catch (...) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21071       };
21072     }
21073   }
21074   jresult = result;
21075   return jresult;
21076 }
21077
21078
21079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21080   Dali::Pixel::Format arg1 ;
21081   int *arg2 = 0 ;
21082   int *arg3 = 0 ;
21083
21084   arg1 = (Dali::Pixel::Format)jarg1;
21085   arg2 = (int *)jarg2;
21086   if (!arg2) {
21087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21088     return ;
21089   }
21090   arg3 = (int *)jarg3;
21091   if (!arg3) {
21092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21093     return ;
21094   }
21095   {
21096     try {
21097       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21098     } catch (std::out_of_range& e) {
21099       {
21100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21101       };
21102     } catch (std::exception& e) {
21103       {
21104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (...) {
21107       {
21108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21109       };
21110     }
21111   }
21112 }
21113
21114
21115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21116   void * jresult ;
21117   unsigned char *arg1 = (unsigned char *) 0 ;
21118   unsigned int arg2 ;
21119   unsigned int arg3 ;
21120   unsigned int arg4 ;
21121   Dali::Pixel::Format arg5 ;
21122   Dali::PixelData::ReleaseFunction arg6 ;
21123   Dali::PixelData result;
21124
21125   arg1 = jarg1;
21126   arg2 = (unsigned int)jarg2;
21127   arg3 = (unsigned int)jarg3;
21128   arg4 = (unsigned int)jarg4;
21129   arg5 = (Dali::Pixel::Format)jarg5;
21130   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21131   {
21132     try {
21133       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21134     } catch (std::out_of_range& e) {
21135       {
21136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21137       };
21138     } catch (std::exception& e) {
21139       {
21140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21141       };
21142     } catch (...) {
21143       {
21144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21145       };
21146     }
21147   }
21148   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21149
21150
21151   return jresult;
21152 }
21153
21154
21155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21156   void * jresult ;
21157   Dali::PixelData *result = 0 ;
21158
21159   {
21160     try {
21161       result = (Dali::PixelData *)new Dali::PixelData();
21162     } catch (std::out_of_range& e) {
21163       {
21164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21165       };
21166     } catch (std::exception& e) {
21167       {
21168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21169       };
21170     } catch (...) {
21171       {
21172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21173       };
21174     }
21175   }
21176   jresult = (void *)result;
21177   return jresult;
21178 }
21179
21180
21181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21182   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21183
21184   arg1 = (Dali::PixelData *)jarg1;
21185   {
21186     try {
21187       delete arg1;
21188     } catch (std::out_of_range& e) {
21189       {
21190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21191       };
21192     } catch (std::exception& e) {
21193       {
21194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21195       };
21196     } catch (...) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21199       };
21200     }
21201   }
21202 }
21203
21204
21205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21206   void * jresult ;
21207   Dali::PixelData *arg1 = 0 ;
21208   Dali::PixelData *result = 0 ;
21209
21210   arg1 = (Dali::PixelData *)jarg1;
21211   if (!arg1) {
21212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21213     return 0;
21214   }
21215   {
21216     try {
21217       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21218     } catch (std::out_of_range& e) {
21219       {
21220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21221       };
21222     } catch (std::exception& e) {
21223       {
21224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21229       };
21230     }
21231   }
21232   jresult = (void *)result;
21233   return jresult;
21234 }
21235
21236
21237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21238   void * jresult ;
21239   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21240   Dali::PixelData *arg2 = 0 ;
21241   Dali::PixelData *result = 0 ;
21242
21243   arg1 = (Dali::PixelData *)jarg1;
21244   arg2 = (Dali::PixelData *)jarg2;
21245   if (!arg2) {
21246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21247     return 0;
21248   }
21249   {
21250     try {
21251       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21252     } catch (std::out_of_range& e) {
21253       {
21254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (std::exception& e) {
21257       {
21258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266   jresult = (void *)result;
21267   return jresult;
21268 }
21269
21270
21271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21272   unsigned int jresult ;
21273   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21274   unsigned int result;
21275
21276   arg1 = (Dali::PixelData *)jarg1;
21277   {
21278     try {
21279       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21280     } catch (std::out_of_range& e) {
21281       {
21282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21283       };
21284     } catch (std::exception& e) {
21285       {
21286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21287       };
21288     } catch (...) {
21289       {
21290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21291       };
21292     }
21293   }
21294   jresult = result;
21295   return jresult;
21296 }
21297
21298
21299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21300   unsigned int jresult ;
21301   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21302   unsigned int result;
21303
21304   arg1 = (Dali::PixelData *)jarg1;
21305   {
21306     try {
21307       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21308     } catch (std::out_of_range& e) {
21309       {
21310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21311       };
21312     } catch (std::exception& e) {
21313       {
21314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21315       };
21316     } catch (...) {
21317       {
21318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21319       };
21320     }
21321   }
21322   jresult = result;
21323   return jresult;
21324 }
21325
21326
21327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21328   int jresult ;
21329   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21330   Dali::Pixel::Format result;
21331
21332   arg1 = (Dali::PixelData *)jarg1;
21333   {
21334     try {
21335       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21336     } catch (std::out_of_range& e) {
21337       {
21338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21339       };
21340     } catch (std::exception& e) {
21341       {
21342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21343       };
21344     } catch (...) {
21345       {
21346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21347       };
21348     }
21349   }
21350   jresult = (int)result;
21351   return jresult;
21352 }
21353
21354
21355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21356   unsigned int jresult ;
21357   unsigned int result;
21358
21359   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21360   jresult = result;
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21366   unsigned int jresult ;
21367   unsigned int result;
21368
21369   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21370   jresult = result;
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21376   unsigned int jresult ;
21377   unsigned int result;
21378
21379   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21380   jresult = result;
21381   return jresult;
21382 }
21383
21384
21385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21386   unsigned int jresult ;
21387   unsigned int result;
21388
21389   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21390   jresult = result;
21391   return jresult;
21392 }
21393
21394
21395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21396   unsigned int jresult ;
21397   unsigned int result;
21398
21399   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21400   jresult = result;
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21406   unsigned int jresult ;
21407   unsigned int result;
21408
21409   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21410   jresult = result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21416   void * jresult ;
21417   Dali::TextureType::Type arg1 ;
21418   Dali::Pixel::Format arg2 ;
21419   unsigned int arg3 ;
21420   unsigned int arg4 ;
21421   Dali::Texture result;
21422
21423   arg1 = (Dali::TextureType::Type)jarg1;
21424   arg2 = (Dali::Pixel::Format)jarg2;
21425   arg3 = (unsigned int)jarg3;
21426   arg4 = (unsigned int)jarg4;
21427   {
21428     try {
21429       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21430     } catch (std::out_of_range& e) {
21431       {
21432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21433       };
21434     } catch (std::exception& e) {
21435       {
21436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21437       };
21438     } catch (...) {
21439       {
21440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21441       };
21442     }
21443   }
21444   jresult = new Dali::Texture((const Dali::Texture &)result);
21445   return jresult;
21446 }
21447
21448
21449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21450   void * jresult ;
21451   NativeImageInterface *arg1 = 0 ;
21452   Dali::Texture result;
21453
21454   arg1 = (NativeImageInterface *)jarg1;
21455   if (!arg1) {
21456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21457     return 0;
21458   }
21459   {
21460     try {
21461       result = Dali::Texture::New(*arg1);
21462     } catch (std::out_of_range& e) {
21463       {
21464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21465       };
21466     } catch (std::exception& e) {
21467       {
21468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21469       };
21470     } catch (...) {
21471       {
21472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21473       };
21474     }
21475   }
21476   jresult = new Dali::Texture((const Dali::Texture &)result);
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21482   void * jresult ;
21483   Dali::Texture *result = 0 ;
21484
21485   {
21486     try {
21487       result = (Dali::Texture *)new Dali::Texture();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (...) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21499       };
21500     }
21501   }
21502   jresult = (void *)result;
21503   return jresult;
21504 }
21505
21506
21507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21508   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21509
21510   arg1 = (Dali::Texture *)jarg1;
21511   {
21512     try {
21513       delete arg1;
21514     } catch (std::out_of_range& e) {
21515       {
21516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21517       };
21518     } catch (std::exception& e) {
21519       {
21520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21521       };
21522     } catch (...) {
21523       {
21524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21525       };
21526     }
21527   }
21528 }
21529
21530
21531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21532   void * jresult ;
21533   Dali::Texture *arg1 = 0 ;
21534   Dali::Texture *result = 0 ;
21535
21536   arg1 = (Dali::Texture *)jarg1;
21537   if (!arg1) {
21538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21539     return 0;
21540   }
21541   {
21542     try {
21543       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21544     } catch (std::out_of_range& e) {
21545       {
21546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21547       };
21548     } catch (std::exception& e) {
21549       {
21550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (...) {
21553       {
21554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21555       };
21556     }
21557   }
21558   jresult = (void *)result;
21559   return jresult;
21560 }
21561
21562
21563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21564   void * jresult ;
21565   Dali::BaseHandle arg1 ;
21566   Dali::BaseHandle *argp1 ;
21567   Dali::Texture result;
21568
21569   argp1 = (Dali::BaseHandle *)jarg1;
21570   if (!argp1) {
21571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21572     return 0;
21573   }
21574   arg1 = *argp1;
21575   {
21576     try {
21577       result = Dali::Texture::DownCast(arg1);
21578     } catch (std::out_of_range& e) {
21579       {
21580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21581       };
21582     } catch (std::exception& e) {
21583       {
21584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21585       };
21586     } catch (...) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21589       };
21590     }
21591   }
21592   jresult = new Dali::Texture((const Dali::Texture &)result);
21593   return jresult;
21594 }
21595
21596
21597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21598   void * jresult ;
21599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21600   Dali::Texture *arg2 = 0 ;
21601   Dali::Texture *result = 0 ;
21602
21603   arg1 = (Dali::Texture *)jarg1;
21604   arg2 = (Dali::Texture *)jarg2;
21605   if (!arg2) {
21606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21607     return 0;
21608   }
21609   {
21610     try {
21611       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21612     } catch (std::out_of_range& e) {
21613       {
21614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21615       };
21616     } catch (std::exception& e) {
21617       {
21618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (...) {
21621       {
21622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21623       };
21624     }
21625   }
21626   jresult = (void *)result;
21627   return jresult;
21628 }
21629
21630
21631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21632   unsigned int jresult ;
21633   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21634   Dali::PixelData arg2 ;
21635   Dali::PixelData *argp2 ;
21636   bool result;
21637
21638   arg1 = (Dali::Texture *)jarg1;
21639   argp2 = (Dali::PixelData *)jarg2;
21640   if (!argp2) {
21641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21642     return 0;
21643   }
21644   arg2 = *argp2;
21645   {
21646     try {
21647       result = (bool)(arg1)->Upload(arg2);
21648     } catch (std::out_of_range& e) {
21649       {
21650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21651       };
21652     } catch (std::exception& e) {
21653       {
21654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21655       };
21656     } catch (...) {
21657       {
21658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21659       };
21660     }
21661   }
21662   jresult = result;
21663   return jresult;
21664 }
21665
21666
21667 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) {
21668   unsigned int jresult ;
21669   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21670   Dali::PixelData arg2 ;
21671   unsigned int arg3 ;
21672   unsigned int arg4 ;
21673   unsigned int arg5 ;
21674   unsigned int arg6 ;
21675   unsigned int arg7 ;
21676   unsigned int arg8 ;
21677   Dali::PixelData *argp2 ;
21678   bool result;
21679
21680   arg1 = (Dali::Texture *)jarg1;
21681   argp2 = (Dali::PixelData *)jarg2;
21682   if (!argp2) {
21683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21684     return 0;
21685   }
21686   arg2 = *argp2;
21687   arg3 = (unsigned int)jarg3;
21688   arg4 = (unsigned int)jarg4;
21689   arg5 = (unsigned int)jarg5;
21690   arg6 = (unsigned int)jarg6;
21691   arg7 = (unsigned int)jarg7;
21692   arg8 = (unsigned int)jarg8;
21693   {
21694     try {
21695       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21696     } catch (std::out_of_range& e) {
21697       {
21698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21699       };
21700     } catch (std::exception& e) {
21701       {
21702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21703       };
21704     } catch (...) {
21705       {
21706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21707       };
21708     }
21709   }
21710   jresult = result;
21711   return jresult;
21712 }
21713
21714
21715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21716   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21717
21718   arg1 = (Dali::Texture *)jarg1;
21719   {
21720     try {
21721       (arg1)->GenerateMipmaps();
21722     } catch (std::out_of_range& e) {
21723       {
21724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (std::exception& e) {
21727       {
21728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736 }
21737
21738
21739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21740   unsigned int jresult ;
21741   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21742   unsigned int result;
21743
21744   arg1 = (Dali::Texture *)jarg1;
21745   {
21746     try {
21747       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21748     } catch (std::out_of_range& e) {
21749       {
21750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (std::exception& e) {
21753       {
21754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (...) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21759       };
21760     }
21761   }
21762   jresult = result;
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21768   unsigned int jresult ;
21769   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21770   unsigned int result;
21771
21772   arg1 = (Dali::Texture *)jarg1;
21773   {
21774     try {
21775       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21776     } catch (std::out_of_range& e) {
21777       {
21778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21779       };
21780     } catch (std::exception& e) {
21781       {
21782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21783       };
21784     } catch (...) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21787       };
21788     }
21789   }
21790   jresult = result;
21791   return jresult;
21792 }
21793
21794
21795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21796   void * jresult ;
21797   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21798   Dali::Texture *result = 0 ;
21799
21800   arg1 = (Dali::Internal::Texture *)jarg1;
21801   {
21802     try {
21803       result = (Dali::Texture *)new Dali::Texture(arg1);
21804     } catch (std::out_of_range& e) {
21805       {
21806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21807       };
21808     } catch (std::exception& e) {
21809       {
21810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21811       };
21812     } catch (...) {
21813       {
21814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21815       };
21816     }
21817   }
21818   jresult = (void *)result;
21819   return jresult;
21820 }
21821
21822
21823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21824   void * jresult ;
21825   Dali::Sampler result;
21826
21827   {
21828     try {
21829       result = Dali::Sampler::New();
21830     } catch (std::out_of_range& e) {
21831       {
21832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (std::exception& e) {
21835       {
21836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (...) {
21839       {
21840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21841       };
21842     }
21843   }
21844   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21845   return jresult;
21846 }
21847
21848
21849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21850   void * jresult ;
21851   Dali::Sampler *result = 0 ;
21852
21853   {
21854     try {
21855       result = (Dali::Sampler *)new Dali::Sampler();
21856     } catch (std::out_of_range& e) {
21857       {
21858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (std::exception& e) {
21861       {
21862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21863       };
21864     } catch (...) {
21865       {
21866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21867       };
21868     }
21869   }
21870   jresult = (void *)result;
21871   return jresult;
21872 }
21873
21874
21875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21876   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21877
21878   arg1 = (Dali::Sampler *)jarg1;
21879   {
21880     try {
21881       delete arg1;
21882     } catch (std::out_of_range& e) {
21883       {
21884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21885       };
21886     } catch (std::exception& e) {
21887       {
21888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21889       };
21890     } catch (...) {
21891       {
21892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21893       };
21894     }
21895   }
21896 }
21897
21898
21899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21900   void * jresult ;
21901   Dali::Sampler *arg1 = 0 ;
21902   Dali::Sampler *result = 0 ;
21903
21904   arg1 = (Dali::Sampler *)jarg1;
21905   if (!arg1) {
21906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21907     return 0;
21908   }
21909   {
21910     try {
21911       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21912     } catch (std::out_of_range& e) {
21913       {
21914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (std::exception& e) {
21917       {
21918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926   jresult = (void *)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21932   void * jresult ;
21933   Dali::BaseHandle arg1 ;
21934   Dali::BaseHandle *argp1 ;
21935   Dali::Sampler result;
21936
21937   argp1 = (Dali::BaseHandle *)jarg1;
21938   if (!argp1) {
21939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21940     return 0;
21941   }
21942   arg1 = *argp1;
21943   {
21944     try {
21945       result = Dali::Sampler::DownCast(arg1);
21946     } catch (std::out_of_range& e) {
21947       {
21948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (std::exception& e) {
21951       {
21952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21961   return jresult;
21962 }
21963
21964
21965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21966   void * jresult ;
21967   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21968   Dali::Sampler *arg2 = 0 ;
21969   Dali::Sampler *result = 0 ;
21970
21971   arg1 = (Dali::Sampler *)jarg1;
21972   arg2 = (Dali::Sampler *)jarg2;
21973   if (!arg2) {
21974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21975     return 0;
21976   }
21977   {
21978     try {
21979       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21980     } catch (std::out_of_range& e) {
21981       {
21982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21983       };
21984     } catch (std::exception& e) {
21985       {
21986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21987       };
21988     } catch (...) {
21989       {
21990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21991       };
21992     }
21993   }
21994   jresult = (void *)result;
21995   return jresult;
21996 }
21997
21998
21999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22000   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22001   Dali::FilterMode::Type arg2 ;
22002   Dali::FilterMode::Type arg3 ;
22003
22004   arg1 = (Dali::Sampler *)jarg1;
22005   arg2 = (Dali::FilterMode::Type)jarg2;
22006   arg3 = (Dali::FilterMode::Type)jarg3;
22007   {
22008     try {
22009       (arg1)->SetFilterMode(arg2,arg3);
22010     } catch (std::out_of_range& e) {
22011       {
22012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22013       };
22014     } catch (std::exception& e) {
22015       {
22016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22017       };
22018     } catch (...) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22021       };
22022     }
22023   }
22024 }
22025
22026
22027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22028   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22029   Dali::WrapMode::Type arg2 ;
22030   Dali::WrapMode::Type arg3 ;
22031
22032   arg1 = (Dali::Sampler *)jarg1;
22033   arg2 = (Dali::WrapMode::Type)jarg2;
22034   arg3 = (Dali::WrapMode::Type)jarg3;
22035   {
22036     try {
22037       (arg1)->SetWrapMode(arg2,arg3);
22038     } catch (std::out_of_range& e) {
22039       {
22040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22041       };
22042     } catch (std::exception& e) {
22043       {
22044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22049       };
22050     }
22051   }
22052 }
22053
22054
22055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22056   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22057   Dali::WrapMode::Type arg2 ;
22058   Dali::WrapMode::Type arg3 ;
22059   Dali::WrapMode::Type arg4 ;
22060
22061   arg1 = (Dali::Sampler *)jarg1;
22062   arg2 = (Dali::WrapMode::Type)jarg2;
22063   arg3 = (Dali::WrapMode::Type)jarg3;
22064   arg4 = (Dali::WrapMode::Type)jarg4;
22065   {
22066     try {
22067       (arg1)->SetWrapMode(arg2,arg3,arg4);
22068     } catch (std::out_of_range& e) {
22069       {
22070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22071       };
22072     } catch (std::exception& e) {
22073       {
22074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22075       };
22076     } catch (...) {
22077       {
22078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22079       };
22080     }
22081   }
22082 }
22083
22084
22085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22086   void * jresult ;
22087   Dali::TextureSet result;
22088
22089   {
22090     try {
22091       result = Dali::TextureSet::New();
22092     } catch (std::out_of_range& e) {
22093       {
22094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22095       };
22096     } catch (std::exception& e) {
22097       {
22098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22099       };
22100     } catch (...) {
22101       {
22102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22103       };
22104     }
22105   }
22106   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22107   return jresult;
22108 }
22109
22110
22111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22112   void * jresult ;
22113   Dali::TextureSet *result = 0 ;
22114
22115   {
22116     try {
22117       result = (Dali::TextureSet *)new Dali::TextureSet();
22118     } catch (std::out_of_range& e) {
22119       {
22120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (std::exception& e) {
22123       {
22124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22125       };
22126     } catch (...) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22129       };
22130     }
22131   }
22132   jresult = (void *)result;
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22138   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22139
22140   arg1 = (Dali::TextureSet *)jarg1;
22141   {
22142     try {
22143       delete arg1;
22144     } catch (std::out_of_range& e) {
22145       {
22146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22147       };
22148     } catch (std::exception& e) {
22149       {
22150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22151       };
22152     } catch (...) {
22153       {
22154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22155       };
22156     }
22157   }
22158 }
22159
22160
22161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22162   void * jresult ;
22163   Dali::TextureSet *arg1 = 0 ;
22164   Dali::TextureSet *result = 0 ;
22165
22166   arg1 = (Dali::TextureSet *)jarg1;
22167   if (!arg1) {
22168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22169     return 0;
22170   }
22171   {
22172     try {
22173       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22174     } catch (std::out_of_range& e) {
22175       {
22176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22177       };
22178     } catch (std::exception& e) {
22179       {
22180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22181       };
22182     } catch (...) {
22183       {
22184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22185       };
22186     }
22187   }
22188   jresult = (void *)result;
22189   return jresult;
22190 }
22191
22192
22193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22194   void * jresult ;
22195   Dali::BaseHandle arg1 ;
22196   Dali::BaseHandle *argp1 ;
22197   Dali::TextureSet result;
22198
22199   argp1 = (Dali::BaseHandle *)jarg1;
22200   if (!argp1) {
22201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22202     return 0;
22203   }
22204   arg1 = *argp1;
22205   {
22206     try {
22207       result = Dali::TextureSet::DownCast(arg1);
22208     } catch (std::out_of_range& e) {
22209       {
22210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22211       };
22212     } catch (std::exception& e) {
22213       {
22214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22215       };
22216     } catch (...) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22219       };
22220     }
22221   }
22222   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22223   return jresult;
22224 }
22225
22226
22227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22228   void * jresult ;
22229   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22230   Dali::TextureSet *arg2 = 0 ;
22231   Dali::TextureSet *result = 0 ;
22232
22233   arg1 = (Dali::TextureSet *)jarg1;
22234   arg2 = (Dali::TextureSet *)jarg2;
22235   if (!arg2) {
22236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22237     return 0;
22238   }
22239   {
22240     try {
22241       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22249       };
22250     } catch (...) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22253       };
22254     }
22255   }
22256   jresult = (void *)result;
22257   return jresult;
22258 }
22259
22260
22261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22262   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22263   size_t arg2 ;
22264   Dali::Texture arg3 ;
22265   Dali::Texture *argp3 ;
22266
22267   arg1 = (Dali::TextureSet *)jarg1;
22268   arg2 = (size_t)jarg2;
22269   argp3 = (Dali::Texture *)jarg3;
22270   if (!argp3) {
22271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22272     return ;
22273   }
22274   arg3 = *argp3;
22275   {
22276     try {
22277       (arg1)->SetTexture(arg2,arg3);
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (...) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22289       };
22290     }
22291   }
22292 }
22293
22294
22295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22296   void * jresult ;
22297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22298   size_t arg2 ;
22299   Dali::Texture result;
22300
22301   arg1 = (Dali::TextureSet *)jarg1;
22302   arg2 = (size_t)jarg2;
22303   {
22304     try {
22305       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22306     } catch (std::out_of_range& e) {
22307       {
22308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22309       };
22310     } catch (std::exception& e) {
22311       {
22312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (...) {
22315       {
22316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22317       };
22318     }
22319   }
22320   jresult = new Dali::Texture((const Dali::Texture &)result);
22321   return jresult;
22322 }
22323
22324
22325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22326   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22327   size_t arg2 ;
22328   Dali::Sampler arg3 ;
22329   Dali::Sampler *argp3 ;
22330
22331   arg1 = (Dali::TextureSet *)jarg1;
22332   arg2 = (size_t)jarg2;
22333   argp3 = (Dali::Sampler *)jarg3;
22334   if (!argp3) {
22335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22336     return ;
22337   }
22338   arg3 = *argp3;
22339   {
22340     try {
22341       (arg1)->SetSampler(arg2,arg3);
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22349       };
22350     } catch (...) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22353       };
22354     }
22355   }
22356 }
22357
22358
22359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22360   void * jresult ;
22361   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22362   size_t arg2 ;
22363   Dali::Sampler result;
22364
22365   arg1 = (Dali::TextureSet *)jarg1;
22366   arg2 = (size_t)jarg2;
22367   {
22368     try {
22369       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22370     } catch (std::out_of_range& e) {
22371       {
22372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (std::exception& e) {
22375       {
22376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22385   return jresult;
22386 }
22387
22388
22389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22390   unsigned long jresult ;
22391   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22392   size_t result;
22393
22394   arg1 = (Dali::TextureSet *)jarg1;
22395   {
22396     try {
22397       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22405       };
22406     } catch (...) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22409       };
22410     }
22411   }
22412   jresult = (unsigned long)result;
22413   return jresult;
22414 }
22415
22416
22417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22418   void * jresult ;
22419   Dali::Property::Map *arg1 = 0 ;
22420   Dali::PropertyBuffer result;
22421
22422   arg1 = (Dali::Property::Map *)jarg1;
22423   if (!arg1) {
22424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22425     return 0;
22426   }
22427   {
22428     try {
22429       result = Dali::PropertyBuffer::New(*arg1);
22430     } catch (std::out_of_range& e) {
22431       {
22432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22433       };
22434     } catch (std::exception& e) {
22435       {
22436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22437       };
22438     } catch (...) {
22439       {
22440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22441       };
22442     }
22443   }
22444   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22445   return jresult;
22446 }
22447
22448
22449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22450   void * jresult ;
22451   Dali::PropertyBuffer *result = 0 ;
22452
22453   {
22454     try {
22455       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22456     } catch (std::out_of_range& e) {
22457       {
22458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22459       };
22460     } catch (std::exception& e) {
22461       {
22462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22463       };
22464     } catch (...) {
22465       {
22466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22467       };
22468     }
22469   }
22470   jresult = (void *)result;
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22476   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22477
22478   arg1 = (Dali::PropertyBuffer *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (...) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22493       };
22494     }
22495   }
22496 }
22497
22498
22499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22500   void * jresult ;
22501   Dali::PropertyBuffer *arg1 = 0 ;
22502   Dali::PropertyBuffer *result = 0 ;
22503
22504   arg1 = (Dali::PropertyBuffer *)jarg1;
22505   if (!arg1) {
22506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22507     return 0;
22508   }
22509   {
22510     try {
22511       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22512     } catch (std::out_of_range& e) {
22513       {
22514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22515       };
22516     } catch (std::exception& e) {
22517       {
22518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22519       };
22520     } catch (...) {
22521       {
22522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22523       };
22524     }
22525   }
22526   jresult = (void *)result;
22527   return jresult;
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22532   void * jresult ;
22533   Dali::BaseHandle arg1 ;
22534   Dali::BaseHandle *argp1 ;
22535   Dali::PropertyBuffer result;
22536
22537   argp1 = (Dali::BaseHandle *)jarg1;
22538   if (!argp1) {
22539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22540     return 0;
22541   }
22542   arg1 = *argp1;
22543   {
22544     try {
22545       result = Dali::PropertyBuffer::DownCast(arg1);
22546     } catch (std::out_of_range& e) {
22547       {
22548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22549       };
22550     } catch (std::exception& e) {
22551       {
22552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22553       };
22554     } catch (...) {
22555       {
22556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22557       };
22558     }
22559   }
22560   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22561   return jresult;
22562 }
22563
22564
22565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22566   void * jresult ;
22567   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22568   Dali::PropertyBuffer *arg2 = 0 ;
22569   Dali::PropertyBuffer *result = 0 ;
22570
22571   arg1 = (Dali::PropertyBuffer *)jarg1;
22572   arg2 = (Dali::PropertyBuffer *)jarg2;
22573   if (!arg2) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22575     return 0;
22576   }
22577   {
22578     try {
22579       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22580     } catch (std::out_of_range& e) {
22581       {
22582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (std::exception& e) {
22585       {
22586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (...) {
22589       {
22590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22591       };
22592     }
22593   }
22594   jresult = (void *)result;
22595   return jresult;
22596 }
22597
22598
22599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22600   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22601   void *arg2 = (void *) 0 ;
22602   std::size_t arg3 ;
22603
22604   arg1 = (Dali::PropertyBuffer *)jarg1;
22605   arg2 = jarg2;
22606   arg3 = (std::size_t)jarg3;
22607   {
22608     try {
22609       (arg1)->SetData((void const *)arg2,arg3);
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22617       };
22618     } catch (...) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22621       };
22622     }
22623   }
22624 }
22625
22626
22627 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22628   unsigned long jresult ;
22629   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22630   std::size_t result;
22631
22632   arg1 = (Dali::PropertyBuffer *)jarg1;
22633   {
22634     try {
22635       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22643       };
22644     } catch (...) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22647       };
22648     }
22649   }
22650   jresult = (unsigned long)result;
22651   return jresult;
22652 }
22653
22654
22655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22656   void * jresult ;
22657   Dali::Geometry result;
22658
22659   {
22660     try {
22661       result = Dali::Geometry::New();
22662     } catch (std::out_of_range& e) {
22663       {
22664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (std::exception& e) {
22667       {
22668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (...) {
22671       {
22672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22673       };
22674     }
22675   }
22676   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22677   return jresult;
22678 }
22679
22680
22681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22682   void * jresult ;
22683   Dali::Geometry *result = 0 ;
22684
22685   {
22686     try {
22687       result = (Dali::Geometry *)new Dali::Geometry();
22688     } catch (std::out_of_range& e) {
22689       {
22690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (std::exception& e) {
22693       {
22694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22695       };
22696     } catch (...) {
22697       {
22698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22699       };
22700     }
22701   }
22702   jresult = (void *)result;
22703   return jresult;
22704 }
22705
22706
22707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22708   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22709
22710   arg1 = (Dali::Geometry *)jarg1;
22711   {
22712     try {
22713       delete arg1;
22714     } catch (std::out_of_range& e) {
22715       {
22716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22717       };
22718     } catch (std::exception& e) {
22719       {
22720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22721       };
22722     } catch (...) {
22723       {
22724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22725       };
22726     }
22727   }
22728 }
22729
22730
22731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22732   void * jresult ;
22733   Dali::Geometry *arg1 = 0 ;
22734   Dali::Geometry *result = 0 ;
22735
22736   arg1 = (Dali::Geometry *)jarg1;
22737   if (!arg1) {
22738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22739     return 0;
22740   }
22741   {
22742     try {
22743       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (...) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22755       };
22756     }
22757   }
22758   jresult = (void *)result;
22759   return jresult;
22760 }
22761
22762
22763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22764   void * jresult ;
22765   Dali::BaseHandle arg1 ;
22766   Dali::BaseHandle *argp1 ;
22767   Dali::Geometry result;
22768
22769   argp1 = (Dali::BaseHandle *)jarg1;
22770   if (!argp1) {
22771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22772     return 0;
22773   }
22774   arg1 = *argp1;
22775   {
22776     try {
22777       result = Dali::Geometry::DownCast(arg1);
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22785       };
22786     } catch (...) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22789       };
22790     }
22791   }
22792   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22793   return jresult;
22794 }
22795
22796
22797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22798   void * jresult ;
22799   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22800   Dali::Geometry *arg2 = 0 ;
22801   Dali::Geometry *result = 0 ;
22802
22803   arg1 = (Dali::Geometry *)jarg1;
22804   arg2 = (Dali::Geometry *)jarg2;
22805   if (!arg2) {
22806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22807     return 0;
22808   }
22809   {
22810     try {
22811       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22812     } catch (std::out_of_range& e) {
22813       {
22814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22815       };
22816     } catch (std::exception& e) {
22817       {
22818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22819       };
22820     } catch (...) {
22821       {
22822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22823       };
22824     }
22825   }
22826   jresult = (void *)result;
22827   return jresult;
22828 }
22829
22830
22831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22832   unsigned long jresult ;
22833   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22834   Dali::PropertyBuffer *arg2 = 0 ;
22835   std::size_t result;
22836
22837   arg1 = (Dali::Geometry *)jarg1;
22838   arg2 = (Dali::PropertyBuffer *)jarg2;
22839   if (!arg2) {
22840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22841     return 0;
22842   }
22843   {
22844     try {
22845       result = (arg1)->AddVertexBuffer(*arg2);
22846     } catch (std::out_of_range& e) {
22847       {
22848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22849       };
22850     } catch (std::exception& e) {
22851       {
22852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22853       };
22854     } catch (...) {
22855       {
22856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22857       };
22858     }
22859   }
22860   jresult = (unsigned long)result;
22861   return jresult;
22862 }
22863
22864
22865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22866   unsigned long jresult ;
22867   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22868   std::size_t result;
22869
22870   arg1 = (Dali::Geometry *)jarg1;
22871   {
22872     try {
22873       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22874     } catch (std::out_of_range& e) {
22875       {
22876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22877       };
22878     } catch (std::exception& e) {
22879       {
22880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (...) {
22883       {
22884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22885       };
22886     }
22887   }
22888   jresult = (unsigned long)result;
22889   return jresult;
22890 }
22891
22892
22893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22894   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22895   std::size_t arg2 ;
22896
22897   arg1 = (Dali::Geometry *)jarg1;
22898   arg2 = (std::size_t)jarg2;
22899   {
22900     try {
22901       (arg1)->RemoveVertexBuffer(arg2);
22902     } catch (std::out_of_range& e) {
22903       {
22904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22905       };
22906     } catch (std::exception& e) {
22907       {
22908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22909       };
22910     } catch (...) {
22911       {
22912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22913       };
22914     }
22915   }
22916 }
22917
22918
22919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22920   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22921   unsigned short *arg2 = (unsigned short *) 0 ;
22922   size_t arg3 ;
22923
22924   arg1 = (Dali::Geometry *)jarg1;
22925   arg2 = jarg2;
22926   arg3 = (size_t)jarg3;
22927   {
22928     try {
22929       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22930     } catch (std::out_of_range& e) {
22931       {
22932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22933       };
22934     } catch (std::exception& e) {
22935       {
22936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22937       };
22938     } catch (...) {
22939       {
22940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22941       };
22942     }
22943   }
22944
22945
22946 }
22947
22948
22949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22950   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22951   Dali::Geometry::Type arg2 ;
22952
22953   arg1 = (Dali::Geometry *)jarg1;
22954   arg2 = (Dali::Geometry::Type)jarg2;
22955   {
22956     try {
22957       (arg1)->SetType(arg2);
22958     } catch (std::out_of_range& e) {
22959       {
22960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22961       };
22962     } catch (std::exception& e) {
22963       {
22964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22965       };
22966     } catch (...) {
22967       {
22968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22969       };
22970     }
22971   }
22972 }
22973
22974
22975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22976   int jresult ;
22977   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22978   Dali::Geometry::Type result;
22979
22980   arg1 = (Dali::Geometry *)jarg1;
22981   {
22982     try {
22983       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22984     } catch (std::out_of_range& e) {
22985       {
22986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22987       };
22988     } catch (std::exception& e) {
22989       {
22990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22991       };
22992     } catch (...) {
22993       {
22994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22995       };
22996     }
22997   }
22998   jresult = (int)result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23004   void * jresult ;
23005   Dali::Shader::Hint *result = 0 ;
23006
23007   {
23008     try {
23009       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23010     } catch (std::out_of_range& e) {
23011       {
23012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23013       };
23014     } catch (std::exception& e) {
23015       {
23016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23017       };
23018     } catch (...) {
23019       {
23020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23021       };
23022     }
23023   }
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23030   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23031
23032   arg1 = (Dali::Shader::Hint *)jarg1;
23033   {
23034     try {
23035       delete arg1;
23036     } catch (std::out_of_range& e) {
23037       {
23038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23039       };
23040     } catch (std::exception& e) {
23041       {
23042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23043       };
23044     } catch (...) {
23045       {
23046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23047       };
23048     }
23049   }
23050 }
23051
23052
23053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23054   int jresult ;
23055   int result;
23056
23057   result = (int)Dali::Shader::Property::PROGRAM;
23058   jresult = (int)result;
23059   return jresult;
23060 }
23061
23062
23063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23064   void * jresult ;
23065   Dali::Shader::Property *result = 0 ;
23066
23067   {
23068     try {
23069       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23070     } catch (std::out_of_range& e) {
23071       {
23072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23073       };
23074     } catch (std::exception& e) {
23075       {
23076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23077       };
23078     } catch (...) {
23079       {
23080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23081       };
23082     }
23083   }
23084   jresult = (void *)result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23090   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23091
23092   arg1 = (Dali::Shader::Property *)jarg1;
23093   {
23094     try {
23095       delete arg1;
23096     } catch (std::out_of_range& e) {
23097       {
23098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23099       };
23100     } catch (std::exception& e) {
23101       {
23102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23103       };
23104     } catch (...) {
23105       {
23106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23107       };
23108     }
23109   }
23110 }
23111
23112
23113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23114   void * jresult ;
23115   std::string *arg1 = 0 ;
23116   std::string *arg2 = 0 ;
23117   Dali::Shader::Hint::Value arg3 ;
23118   Dali::Shader result;
23119
23120   if (!jarg1) {
23121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23122     return 0;
23123   }
23124   std::string arg1_str(jarg1);
23125   arg1 = &arg1_str;
23126   if (!jarg2) {
23127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23128     return 0;
23129   }
23130   std::string arg2_str(jarg2);
23131   arg2 = &arg2_str;
23132   arg3 = (Dali::Shader::Hint::Value)jarg3;
23133   {
23134     try {
23135       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23136     } catch (std::out_of_range& e) {
23137       {
23138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23139       };
23140     } catch (std::exception& e) {
23141       {
23142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23143       };
23144     } catch (...) {
23145       {
23146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23147       };
23148     }
23149   }
23150   jresult = new Dali::Shader((const Dali::Shader &)result);
23151
23152   //argout typemap for const std::string&
23153
23154
23155   //argout typemap for const std::string&
23156
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23162   void * jresult ;
23163   std::string *arg1 = 0 ;
23164   std::string *arg2 = 0 ;
23165   Dali::Shader result;
23166
23167   if (!jarg1) {
23168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23169     return 0;
23170   }
23171   std::string arg1_str(jarg1);
23172   arg1 = &arg1_str;
23173   if (!jarg2) {
23174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23175     return 0;
23176   }
23177   std::string arg2_str(jarg2);
23178   arg2 = &arg2_str;
23179   {
23180     try {
23181       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23182     } catch (std::out_of_range& e) {
23183       {
23184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23185       };
23186     } catch (std::exception& e) {
23187       {
23188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23189       };
23190     } catch (...) {
23191       {
23192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23193       };
23194     }
23195   }
23196   jresult = new Dali::Shader((const Dali::Shader &)result);
23197
23198   //argout typemap for const std::string&
23199
23200
23201   //argout typemap for const std::string&
23202
23203   return jresult;
23204 }
23205
23206
23207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23208   void * jresult ;
23209   Dali::Shader *result = 0 ;
23210
23211   {
23212     try {
23213       result = (Dali::Shader *)new Dali::Shader();
23214     } catch (std::out_of_range& e) {
23215       {
23216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23217       };
23218     } catch (std::exception& e) {
23219       {
23220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23221       };
23222     } catch (...) {
23223       {
23224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23225       };
23226     }
23227   }
23228   jresult = (void *)result;
23229   return jresult;
23230 }
23231
23232
23233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23234   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23235
23236   arg1 = (Dali::Shader *)jarg1;
23237   {
23238     try {
23239       delete arg1;
23240     } catch (std::out_of_range& e) {
23241       {
23242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23243       };
23244     } catch (std::exception& e) {
23245       {
23246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23247       };
23248     } catch (...) {
23249       {
23250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23251       };
23252     }
23253   }
23254 }
23255
23256
23257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23258   void * jresult ;
23259   Dali::Shader *arg1 = 0 ;
23260   Dali::Shader *result = 0 ;
23261
23262   arg1 = (Dali::Shader *)jarg1;
23263   if (!arg1) {
23264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23265     return 0;
23266   }
23267   {
23268     try {
23269       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23270     } catch (std::out_of_range& e) {
23271       {
23272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23273       };
23274     } catch (std::exception& e) {
23275       {
23276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23277       };
23278     } catch (...) {
23279       {
23280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23281       };
23282     }
23283   }
23284   jresult = (void *)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23290   void * jresult ;
23291   Dali::BaseHandle arg1 ;
23292   Dali::BaseHandle *argp1 ;
23293   Dali::Shader result;
23294
23295   argp1 = (Dali::BaseHandle *)jarg1;
23296   if (!argp1) {
23297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23298     return 0;
23299   }
23300   arg1 = *argp1;
23301   {
23302     try {
23303       result = Dali::Shader::DownCast(arg1);
23304     } catch (std::out_of_range& e) {
23305       {
23306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23307       };
23308     } catch (std::exception& e) {
23309       {
23310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23311       };
23312     } catch (...) {
23313       {
23314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23315       };
23316     }
23317   }
23318   jresult = new Dali::Shader((const Dali::Shader &)result);
23319   return jresult;
23320 }
23321
23322
23323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23324   void * jresult ;
23325   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23326   Dali::Shader *arg2 = 0 ;
23327   Dali::Shader *result = 0 ;
23328
23329   arg1 = (Dali::Shader *)jarg1;
23330   arg2 = (Dali::Shader *)jarg2;
23331   if (!arg2) {
23332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23333     return 0;
23334   }
23335   {
23336     try {
23337       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23338     } catch (std::out_of_range& e) {
23339       {
23340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23341       };
23342     } catch (std::exception& e) {
23343       {
23344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23345       };
23346     } catch (...) {
23347       {
23348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23349       };
23350     }
23351   }
23352   jresult = (void *)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::BLEND_MODE;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Renderer::Property::RENDER_MODE;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23538   int jresult ;
23539   int result;
23540
23541   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23542   jresult = (int)result;
23543   return jresult;
23544 }
23545
23546
23547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23548   int jresult ;
23549   int result;
23550
23551   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23552   jresult = (int)result;
23553   return jresult;
23554 }
23555
23556
23557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23558   int jresult ;
23559   int result;
23560
23561   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23562   jresult = (int)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23568   int jresult ;
23569   int result;
23570
23571   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23572   jresult = (int)result;
23573   return jresult;
23574 }
23575
23576
23577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23578   int jresult ;
23579   int result;
23580
23581   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23582   jresult = (int)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23588   int jresult ;
23589   int result;
23590
23591   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23592   jresult = (int)result;
23593   return jresult;
23594 }
23595
23596
23597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23598   void * jresult ;
23599   Dali::Renderer::Property *result = 0 ;
23600
23601   {
23602     try {
23603       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23604     } catch (std::out_of_range& e) {
23605       {
23606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23607       };
23608     } catch (std::exception& e) {
23609       {
23610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23615       };
23616     }
23617   }
23618   jresult = (void *)result;
23619   return jresult;
23620 }
23621
23622
23623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23624   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23625
23626   arg1 = (Dali::Renderer::Property *)jarg1;
23627   {
23628     try {
23629       delete arg1;
23630     } catch (std::out_of_range& e) {
23631       {
23632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23633       };
23634     } catch (std::exception& e) {
23635       {
23636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23637       };
23638     } catch (...) {
23639       {
23640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23641       };
23642     }
23643   }
23644 }
23645
23646
23647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23648   void * jresult ;
23649   Dali::Geometry *arg1 = 0 ;
23650   Dali::Shader *arg2 = 0 ;
23651   Dali::Renderer result;
23652
23653   arg1 = (Dali::Geometry *)jarg1;
23654   if (!arg1) {
23655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23656     return 0;
23657   }
23658   arg2 = (Dali::Shader *)jarg2;
23659   if (!arg2) {
23660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23661     return 0;
23662   }
23663   {
23664     try {
23665       result = Dali::Renderer::New(*arg1,*arg2);
23666     } catch (std::out_of_range& e) {
23667       {
23668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23669       };
23670     } catch (std::exception& e) {
23671       {
23672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (...) {
23675       {
23676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23677       };
23678     }
23679   }
23680   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23681   return jresult;
23682 }
23683
23684
23685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23686   void * jresult ;
23687   Dali::Renderer *result = 0 ;
23688
23689   {
23690     try {
23691       result = (Dali::Renderer *)new Dali::Renderer();
23692     } catch (std::out_of_range& e) {
23693       {
23694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23695       };
23696     } catch (std::exception& e) {
23697       {
23698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23699       };
23700     } catch (...) {
23701       {
23702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23703       };
23704     }
23705   }
23706   jresult = (void *)result;
23707   return jresult;
23708 }
23709
23710
23711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23712   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23713
23714   arg1 = (Dali::Renderer *)jarg1;
23715   {
23716     try {
23717       delete arg1;
23718     } catch (std::out_of_range& e) {
23719       {
23720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23721       };
23722     } catch (std::exception& e) {
23723       {
23724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23725       };
23726     } catch (...) {
23727       {
23728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23729       };
23730     }
23731   }
23732 }
23733
23734
23735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23736   void * jresult ;
23737   Dali::Renderer *arg1 = 0 ;
23738   Dali::Renderer *result = 0 ;
23739
23740   arg1 = (Dali::Renderer *)jarg1;
23741   if (!arg1) {
23742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23743     return 0;
23744   }
23745   {
23746     try {
23747       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23748     } catch (std::out_of_range& e) {
23749       {
23750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (std::exception& e) {
23753       {
23754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762   jresult = (void *)result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23768   void * jresult ;
23769   Dali::BaseHandle arg1 ;
23770   Dali::BaseHandle *argp1 ;
23771   Dali::Renderer result;
23772
23773   argp1 = (Dali::BaseHandle *)jarg1;
23774   if (!argp1) {
23775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23776     return 0;
23777   }
23778   arg1 = *argp1;
23779   {
23780     try {
23781       result = Dali::Renderer::DownCast(arg1);
23782     } catch (std::out_of_range& e) {
23783       {
23784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23785       };
23786     } catch (std::exception& e) {
23787       {
23788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23789       };
23790     } catch (...) {
23791       {
23792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23793       };
23794     }
23795   }
23796   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23802   void * jresult ;
23803   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23804   Dali::Renderer *arg2 = 0 ;
23805   Dali::Renderer *result = 0 ;
23806
23807   arg1 = (Dali::Renderer *)jarg1;
23808   arg2 = (Dali::Renderer *)jarg2;
23809   if (!arg2) {
23810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23811     return 0;
23812   }
23813   {
23814     try {
23815       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23816     } catch (std::out_of_range& e) {
23817       {
23818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (std::exception& e) {
23821       {
23822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830   jresult = (void *)result;
23831   return jresult;
23832 }
23833
23834
23835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23836   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23837   Dali::Geometry *arg2 = 0 ;
23838
23839   arg1 = (Dali::Renderer *)jarg1;
23840   arg2 = (Dali::Geometry *)jarg2;
23841   if (!arg2) {
23842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23843     return ;
23844   }
23845   {
23846     try {
23847       (arg1)->SetGeometry(*arg2);
23848     } catch (std::out_of_range& e) {
23849       {
23850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23851       };
23852     } catch (std::exception& e) {
23853       {
23854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23855       };
23856     } catch (...) {
23857       {
23858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23859       };
23860     }
23861   }
23862 }
23863
23864
23865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23866   void * jresult ;
23867   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23868   Dali::Geometry result;
23869
23870   arg1 = (Dali::Renderer *)jarg1;
23871   {
23872     try {
23873       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23874     } catch (std::out_of_range& e) {
23875       {
23876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23877       };
23878     } catch (std::exception& e) {
23879       {
23880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23881       };
23882     } catch (...) {
23883       {
23884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23885       };
23886     }
23887   }
23888   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23889   return jresult;
23890 }
23891
23892
23893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23894   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23895   int arg2 ;
23896   int arg3 ;
23897
23898   arg1 = (Dali::Renderer *)jarg1;
23899   arg2 = (int)jarg2;
23900   arg3 = (int)jarg3;
23901   {
23902     try {
23903       (arg1)->SetIndexRange(arg2,arg3);
23904     } catch (std::out_of_range& e) {
23905       {
23906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23907       };
23908     } catch (std::exception& e) {
23909       {
23910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23911       };
23912     } catch (...) {
23913       {
23914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23915       };
23916     }
23917   }
23918 }
23919
23920
23921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23922   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23923   Dali::TextureSet *arg2 = 0 ;
23924
23925   arg1 = (Dali::Renderer *)jarg1;
23926   arg2 = (Dali::TextureSet *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23929     return ;
23930   }
23931   {
23932     try {
23933       (arg1)->SetTextures(*arg2);
23934     } catch (std::out_of_range& e) {
23935       {
23936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23937       };
23938     } catch (std::exception& e) {
23939       {
23940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (...) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23945       };
23946     }
23947   }
23948 }
23949
23950
23951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23952   void * jresult ;
23953   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23954   Dali::TextureSet result;
23955
23956   arg1 = (Dali::Renderer *)jarg1;
23957   {
23958     try {
23959       result = ((Dali::Renderer const *)arg1)->GetTextures();
23960     } catch (std::out_of_range& e) {
23961       {
23962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23963       };
23964     } catch (std::exception& e) {
23965       {
23966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23967       };
23968     } catch (...) {
23969       {
23970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23971       };
23972     }
23973   }
23974   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23975   return jresult;
23976 }
23977
23978
23979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23980   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23981   Dali::Shader *arg2 = 0 ;
23982
23983   arg1 = (Dali::Renderer *)jarg1;
23984   arg2 = (Dali::Shader *)jarg2;
23985   if (!arg2) {
23986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23987     return ;
23988   }
23989   {
23990     try {
23991       (arg1)->SetShader(*arg2);
23992     } catch (std::out_of_range& e) {
23993       {
23994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23995       };
23996     } catch (std::exception& e) {
23997       {
23998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23999       };
24000     } catch (...) {
24001       {
24002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24003       };
24004     }
24005   }
24006 }
24007
24008
24009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24010   void * jresult ;
24011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24012   Dali::Shader result;
24013
24014   arg1 = (Dali::Renderer *)jarg1;
24015   {
24016     try {
24017       result = ((Dali::Renderer const *)arg1)->GetShader();
24018     } catch (std::out_of_range& e) {
24019       {
24020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24021       };
24022     } catch (std::exception& e) {
24023       {
24024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24025       };
24026     } catch (...) {
24027       {
24028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24029       };
24030     }
24031   }
24032   jresult = new Dali::Shader((const Dali::Shader &)result);
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24038   void * jresult ;
24039   Dali::FrameBuffer::Attachment *result = 0 ;
24040
24041   {
24042     try {
24043       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24051       };
24052     } catch (...) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24055       };
24056     }
24057   }
24058   jresult = (void *)result;
24059   return jresult;
24060 }
24061
24062
24063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24064   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24065
24066   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24067   {
24068     try {
24069       delete arg1;
24070     } catch (std::out_of_range& e) {
24071       {
24072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24073       };
24074     } catch (std::exception& e) {
24075       {
24076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24077       };
24078     } catch (...) {
24079       {
24080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24081       };
24082     }
24083   }
24084 }
24085
24086
24087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24088   void * jresult ;
24089   unsigned int arg1 ;
24090   unsigned int arg2 ;
24091   unsigned int arg3 ;
24092   Dali::FrameBuffer result;
24093
24094   arg1 = (unsigned int)jarg1;
24095   arg2 = (unsigned int)jarg2;
24096   arg3 = (unsigned int)jarg3;
24097   {
24098     try {
24099       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24100     } catch (std::out_of_range& e) {
24101       {
24102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (std::exception& e) {
24105       {
24106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (...) {
24109       {
24110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24111       };
24112     }
24113   }
24114   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24115   return jresult;
24116 }
24117
24118
24119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24120   void * jresult ;
24121   Dali::FrameBuffer *result = 0 ;
24122
24123   {
24124     try {
24125       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24126     } catch (std::out_of_range& e) {
24127       {
24128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (std::exception& e) {
24131       {
24132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140   jresult = (void *)result;
24141   return jresult;
24142 }
24143
24144
24145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24146   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24147
24148   arg1 = (Dali::FrameBuffer *)jarg1;
24149   {
24150     try {
24151       delete arg1;
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24163       };
24164     }
24165   }
24166 }
24167
24168
24169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24170   void * jresult ;
24171   Dali::FrameBuffer *arg1 = 0 ;
24172   Dali::FrameBuffer *result = 0 ;
24173
24174   arg1 = (Dali::FrameBuffer *)jarg1;
24175   if (!arg1) {
24176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24177     return 0;
24178   }
24179   {
24180     try {
24181       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24182     } catch (std::out_of_range& e) {
24183       {
24184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24185       };
24186     } catch (std::exception& e) {
24187       {
24188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24189       };
24190     } catch (...) {
24191       {
24192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24193       };
24194     }
24195   }
24196   jresult = (void *)result;
24197   return jresult;
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24202   void * jresult ;
24203   Dali::BaseHandle arg1 ;
24204   Dali::BaseHandle *argp1 ;
24205   Dali::FrameBuffer result;
24206
24207   argp1 = (Dali::BaseHandle *)jarg1;
24208   if (!argp1) {
24209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24210     return 0;
24211   }
24212   arg1 = *argp1;
24213   {
24214     try {
24215       result = Dali::FrameBuffer::DownCast(arg1);
24216     } catch (std::out_of_range& e) {
24217       {
24218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24219       };
24220     } catch (std::exception& e) {
24221       {
24222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24223       };
24224     } catch (...) {
24225       {
24226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24227       };
24228     }
24229   }
24230   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24231   return jresult;
24232 }
24233
24234
24235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24236   void * jresult ;
24237   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24238   Dali::FrameBuffer *arg2 = 0 ;
24239   Dali::FrameBuffer *result = 0 ;
24240
24241   arg1 = (Dali::FrameBuffer *)jarg1;
24242   arg2 = (Dali::FrameBuffer *)jarg2;
24243   if (!arg2) {
24244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24245     return 0;
24246   }
24247   {
24248     try {
24249       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24250     } catch (std::out_of_range& e) {
24251       {
24252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24253       };
24254     } catch (std::exception& e) {
24255       {
24256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24257       };
24258     } catch (...) {
24259       {
24260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24261       };
24262     }
24263   }
24264   jresult = (void *)result;
24265   return jresult;
24266 }
24267
24268
24269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24270   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24271   Dali::Texture *arg2 = 0 ;
24272
24273   arg1 = (Dali::FrameBuffer *)jarg1;
24274   arg2 = (Dali::Texture *)jarg2;
24275   if (!arg2) {
24276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24277     return ;
24278   }
24279   {
24280     try {
24281       (arg1)->AttachColorTexture(*arg2);
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24293       };
24294     }
24295   }
24296 }
24297
24298
24299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24300   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24301   Dali::Texture *arg2 = 0 ;
24302   unsigned int arg3 ;
24303   unsigned int arg4 ;
24304
24305   arg1 = (Dali::FrameBuffer *)jarg1;
24306   arg2 = (Dali::Texture *)jarg2;
24307   if (!arg2) {
24308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24309     return ;
24310   }
24311   arg3 = (unsigned int)jarg3;
24312   arg4 = (unsigned int)jarg4;
24313   {
24314     try {
24315       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24323       };
24324     } catch (...) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24327       };
24328     }
24329   }
24330 }
24331
24332
24333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24334   void * jresult ;
24335   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24336   Dali::Texture result;
24337
24338   arg1 = (Dali::FrameBuffer *)jarg1;
24339   {
24340     try {
24341       result = (arg1)->GetColorTexture();
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (...) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24353       };
24354     }
24355   }
24356   jresult = new Dali::Texture((const Dali::Texture &)result);
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24362   void * jresult ;
24363   Dali::RenderTaskList *result = 0 ;
24364
24365   {
24366     try {
24367       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24368     } catch (std::out_of_range& e) {
24369       {
24370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24371       };
24372     } catch (std::exception& e) {
24373       {
24374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24375       };
24376     } catch (...) {
24377       {
24378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24379       };
24380     }
24381   }
24382   jresult = (void *)result;
24383   return jresult;
24384 }
24385
24386
24387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24388   void * jresult ;
24389   Dali::BaseHandle arg1 ;
24390   Dali::BaseHandle *argp1 ;
24391   Dali::RenderTaskList result;
24392
24393   argp1 = (Dali::BaseHandle *)jarg1;
24394   if (!argp1) {
24395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24396     return 0;
24397   }
24398   arg1 = *argp1;
24399   {
24400     try {
24401       result = Dali::RenderTaskList::DownCast(arg1);
24402     } catch (std::out_of_range& e) {
24403       {
24404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24405       };
24406     } catch (std::exception& e) {
24407       {
24408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24409       };
24410     } catch (...) {
24411       {
24412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24413       };
24414     }
24415   }
24416   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24417   return jresult;
24418 }
24419
24420
24421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24422   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24423
24424   arg1 = (Dali::RenderTaskList *)jarg1;
24425   {
24426     try {
24427       delete arg1;
24428     } catch (std::out_of_range& e) {
24429       {
24430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24431       };
24432     } catch (std::exception& e) {
24433       {
24434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24435       };
24436     } catch (...) {
24437       {
24438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24439       };
24440     }
24441   }
24442 }
24443
24444
24445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24446   void * jresult ;
24447   Dali::RenderTaskList *arg1 = 0 ;
24448   Dali::RenderTaskList *result = 0 ;
24449
24450   arg1 = (Dali::RenderTaskList *)jarg1;
24451   if (!arg1) {
24452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24453     return 0;
24454   }
24455   {
24456     try {
24457       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24458     } catch (std::out_of_range& e) {
24459       {
24460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (std::exception& e) {
24463       {
24464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472   jresult = (void *)result;
24473   return jresult;
24474 }
24475
24476
24477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24478   void * jresult ;
24479   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24480   Dali::RenderTaskList *arg2 = 0 ;
24481   Dali::RenderTaskList *result = 0 ;
24482
24483   arg1 = (Dali::RenderTaskList *)jarg1;
24484   arg2 = (Dali::RenderTaskList *)jarg2;
24485   if (!arg2) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24487     return 0;
24488   }
24489   {
24490     try {
24491       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24492     } catch (std::out_of_range& e) {
24493       {
24494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (std::exception& e) {
24497       {
24498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24499       };
24500     } catch (...) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24503       };
24504     }
24505   }
24506   jresult = (void *)result;
24507   return jresult;
24508 }
24509
24510
24511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24512   void * jresult ;
24513   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24514   Dali::RenderTask result;
24515
24516   arg1 = (Dali::RenderTaskList *)jarg1;
24517   {
24518     try {
24519       result = (arg1)->CreateTask();
24520     } catch (std::out_of_range& e) {
24521       {
24522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (std::exception& e) {
24525       {
24526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24540   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24541   Dali::RenderTask arg2 ;
24542   Dali::RenderTask *argp2 ;
24543
24544   arg1 = (Dali::RenderTaskList *)jarg1;
24545   argp2 = (Dali::RenderTask *)jarg2;
24546   if (!argp2) {
24547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24548     return ;
24549   }
24550   arg2 = *argp2;
24551   {
24552     try {
24553       (arg1)->RemoveTask(arg2);
24554     } catch (std::out_of_range& e) {
24555       {
24556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24557       };
24558     } catch (std::exception& e) {
24559       {
24560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24561       };
24562     } catch (...) {
24563       {
24564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24565       };
24566     }
24567   }
24568 }
24569
24570
24571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24572   unsigned int jresult ;
24573   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24574   unsigned int result;
24575
24576   arg1 = (Dali::RenderTaskList *)jarg1;
24577   {
24578     try {
24579       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24580     } catch (std::out_of_range& e) {
24581       {
24582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24583       };
24584     } catch (std::exception& e) {
24585       {
24586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24587       };
24588     } catch (...) {
24589       {
24590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24591       };
24592     }
24593   }
24594   jresult = result;
24595   return jresult;
24596 }
24597
24598
24599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24600   void * jresult ;
24601   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24602   unsigned int arg2 ;
24603   Dali::RenderTask result;
24604
24605   arg1 = (Dali::RenderTaskList *)jarg1;
24606   arg2 = (unsigned int)jarg2;
24607   {
24608     try {
24609       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24610     } catch (std::out_of_range& e) {
24611       {
24612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24613       };
24614     } catch (std::exception& e) {
24615       {
24616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24617       };
24618     } catch (...) {
24619       {
24620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24621       };
24622     }
24623   }
24624   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24625   return jresult;
24626 }
24627
24628
24629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24630   int jresult ;
24631   int result;
24632
24633   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24634   jresult = (int)result;
24635   return jresult;
24636 }
24637
24638
24639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24640   int jresult ;
24641   int result;
24642
24643   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24644   jresult = (int)result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24650   int jresult ;
24651   int result;
24652
24653   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24654   jresult = (int)result;
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24660   int jresult ;
24661   int result;
24662
24663   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24664   jresult = (int)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24670   void * jresult ;
24671   Dali::RenderTask::Property *result = 0 ;
24672
24673   {
24674     try {
24675       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24676     } catch (std::out_of_range& e) {
24677       {
24678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24679       };
24680     } catch (std::exception& e) {
24681       {
24682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24683       };
24684     } catch (...) {
24685       {
24686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24687       };
24688     }
24689   }
24690   jresult = (void *)result;
24691   return jresult;
24692 }
24693
24694
24695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24696   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24697
24698   arg1 = (Dali::RenderTask::Property *)jarg1;
24699   {
24700     try {
24701       delete arg1;
24702     } catch (std::out_of_range& e) {
24703       {
24704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24705       };
24706     } catch (std::exception& e) {
24707       {
24708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24709       };
24710     } catch (...) {
24711       {
24712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24713       };
24714     }
24715   }
24716 }
24717
24718
24719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24720   void * jresult ;
24721   bool (*result)(Dali::Vector2 &) = 0 ;
24722
24723   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24724   jresult = (void *)result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24730   void * jresult ;
24731   bool (*result)(Dali::Vector2 &) = 0 ;
24732
24733   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24734   jresult = (void *)result;
24735   return jresult;
24736 }
24737
24738
24739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24740   unsigned int jresult ;
24741   bool result;
24742
24743   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24744   jresult = result;
24745   return jresult;
24746 }
24747
24748
24749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24750   unsigned int jresult ;
24751   bool result;
24752
24753   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24754   jresult = result;
24755   return jresult;
24756 }
24757
24758
24759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24760   void * jresult ;
24761   Dali::Vector4 *result = 0 ;
24762
24763   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24764   jresult = (void *)result;
24765   return jresult;
24766 }
24767
24768
24769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24770   unsigned int jresult ;
24771   bool result;
24772
24773   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24774   jresult = result;
24775   return jresult;
24776 }
24777
24778
24779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24780   unsigned int jresult ;
24781   bool result;
24782
24783   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24784   jresult = result;
24785   return jresult;
24786 }
24787
24788
24789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24790   unsigned int jresult ;
24791   unsigned int result;
24792
24793   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24794   jresult = result;
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24800   void * jresult ;
24801   Dali::RenderTask *result = 0 ;
24802
24803   {
24804     try {
24805       result = (Dali::RenderTask *)new Dali::RenderTask();
24806     } catch (std::out_of_range& e) {
24807       {
24808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24809       };
24810     } catch (std::exception& e) {
24811       {
24812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24813       };
24814     } catch (...) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24817       };
24818     }
24819   }
24820   jresult = (void *)result;
24821   return jresult;
24822 }
24823
24824
24825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24826   void * jresult ;
24827   Dali::BaseHandle arg1 ;
24828   Dali::BaseHandle *argp1 ;
24829   Dali::RenderTask result;
24830
24831   argp1 = (Dali::BaseHandle *)jarg1;
24832   if (!argp1) {
24833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24834     return 0;
24835   }
24836   arg1 = *argp1;
24837   {
24838     try {
24839       result = Dali::RenderTask::DownCast(arg1);
24840     } catch (std::out_of_range& e) {
24841       {
24842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (std::exception& e) {
24845       {
24846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24847       };
24848     } catch (...) {
24849       {
24850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24851       };
24852     }
24853   }
24854   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24855   return jresult;
24856 }
24857
24858
24859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24860   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24861
24862   arg1 = (Dali::RenderTask *)jarg1;
24863   {
24864     try {
24865       delete arg1;
24866     } catch (std::out_of_range& e) {
24867       {
24868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24869       };
24870     } catch (std::exception& e) {
24871       {
24872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24873       };
24874     } catch (...) {
24875       {
24876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24877       };
24878     }
24879   }
24880 }
24881
24882
24883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24884   void * jresult ;
24885   Dali::RenderTask *arg1 = 0 ;
24886   Dali::RenderTask *result = 0 ;
24887
24888   arg1 = (Dali::RenderTask *)jarg1;
24889   if (!arg1) {
24890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24891     return 0;
24892   }
24893   {
24894     try {
24895       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24896     } catch (std::out_of_range& e) {
24897       {
24898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24899       };
24900     } catch (std::exception& e) {
24901       {
24902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24903       };
24904     } catch (...) {
24905       {
24906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24907       };
24908     }
24909   }
24910   jresult = (void *)result;
24911   return jresult;
24912 }
24913
24914
24915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24916   void * jresult ;
24917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24918   Dali::RenderTask *arg2 = 0 ;
24919   Dali::RenderTask *result = 0 ;
24920
24921   arg1 = (Dali::RenderTask *)jarg1;
24922   arg2 = (Dali::RenderTask *)jarg2;
24923   if (!arg2) {
24924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24925     return 0;
24926   }
24927   {
24928     try {
24929       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24930     } catch (std::out_of_range& e) {
24931       {
24932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24933       };
24934     } catch (std::exception& e) {
24935       {
24936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24937       };
24938     } catch (...) {
24939       {
24940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24941       };
24942     }
24943   }
24944   jresult = (void *)result;
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24951   Dali::Actor arg2 ;
24952   Dali::Actor *argp2 ;
24953
24954   arg1 = (Dali::RenderTask *)jarg1;
24955   argp2 = (Dali::Actor *)jarg2;
24956   if (!argp2) {
24957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24958     return ;
24959   }
24960   arg2 = *argp2;
24961   {
24962     try {
24963       (arg1)->SetSourceActor(arg2);
24964     } catch (std::out_of_range& e) {
24965       {
24966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24967       };
24968     } catch (std::exception& e) {
24969       {
24970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24975       };
24976     }
24977   }
24978 }
24979
24980
24981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24982   void * jresult ;
24983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24984   Dali::Actor result;
24985
24986   arg1 = (Dali::RenderTask *)jarg1;
24987   {
24988     try {
24989       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24990     } catch (std::out_of_range& e) {
24991       {
24992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24993       };
24994     } catch (std::exception& e) {
24995       {
24996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24997       };
24998     } catch (...) {
24999       {
25000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25001       };
25002     }
25003   }
25004   jresult = new Dali::Actor((const Dali::Actor &)result);
25005   return jresult;
25006 }
25007
25008
25009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25010   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25011   bool arg2 ;
25012
25013   arg1 = (Dali::RenderTask *)jarg1;
25014   arg2 = jarg2 ? true : false;
25015   {
25016     try {
25017       (arg1)->SetExclusive(arg2);
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25029       };
25030     }
25031   }
25032 }
25033
25034
25035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25036   unsigned int jresult ;
25037   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25038   bool result;
25039
25040   arg1 = (Dali::RenderTask *)jarg1;
25041   {
25042     try {
25043       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25044     } catch (std::out_of_range& e) {
25045       {
25046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25047       };
25048     } catch (std::exception& e) {
25049       {
25050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25051       };
25052     } catch (...) {
25053       {
25054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25055       };
25056     }
25057   }
25058   jresult = result;
25059   return jresult;
25060 }
25061
25062
25063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25064   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25065   bool arg2 ;
25066
25067   arg1 = (Dali::RenderTask *)jarg1;
25068   arg2 = jarg2 ? true : false;
25069   {
25070     try {
25071       (arg1)->SetInputEnabled(arg2);
25072     } catch (std::out_of_range& e) {
25073       {
25074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25075       };
25076     } catch (std::exception& e) {
25077       {
25078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25083       };
25084     }
25085   }
25086 }
25087
25088
25089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25090   unsigned int jresult ;
25091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25092   bool result;
25093
25094   arg1 = (Dali::RenderTask *)jarg1;
25095   {
25096     try {
25097       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25098     } catch (std::out_of_range& e) {
25099       {
25100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25101       };
25102     } catch (std::exception& e) {
25103       {
25104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25109       };
25110     }
25111   }
25112   jresult = result;
25113   return jresult;
25114 }
25115
25116
25117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25119   Dali::CameraActor arg2 ;
25120   Dali::CameraActor *argp2 ;
25121
25122   arg1 = (Dali::RenderTask *)jarg1;
25123   argp2 = (Dali::CameraActor *)jarg2;
25124   if (!argp2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25126     return ;
25127   }
25128   arg2 = *argp2;
25129   {
25130     try {
25131       (arg1)->SetCameraActor(arg2);
25132     } catch (std::out_of_range& e) {
25133       {
25134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25135       };
25136     } catch (std::exception& e) {
25137       {
25138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25143       };
25144     }
25145   }
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25150   void * jresult ;
25151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25152   Dali::CameraActor result;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25179   Dali::FrameBufferImage arg2 ;
25180   Dali::FrameBufferImage *argp2 ;
25181
25182   arg1 = (Dali::RenderTask *)jarg1;
25183   argp2 = (Dali::FrameBufferImage *)jarg2;
25184   if (!argp2) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25186     return ;
25187   }
25188   arg2 = *argp2;
25189   {
25190     try {
25191       (arg1)->SetTargetFrameBuffer(arg2);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25203       };
25204     }
25205   }
25206 }
25207
25208
25209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25210   void * jresult ;
25211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25212   Dali::FrameBufferImage result;
25213
25214   arg1 = (Dali::RenderTask *)jarg1;
25215   {
25216     try {
25217       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25218     } catch (std::out_of_range& e) {
25219       {
25220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25221       };
25222     } catch (std::exception& e) {
25223       {
25224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25225       };
25226     } catch (...) {
25227       {
25228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25229       };
25230     }
25231   }
25232   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25233   return jresult;
25234 }
25235
25236
25237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25239   Dali::FrameBuffer arg2 ;
25240   Dali::FrameBuffer *argp2 ;
25241
25242   arg1 = (Dali::RenderTask *)jarg1;
25243   argp2 = (Dali::FrameBuffer *)jarg2;
25244   if (!argp2) {
25245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25246     return ;
25247   }
25248   arg2 = *argp2;
25249   {
25250     try {
25251       (arg1)->SetFrameBuffer(arg2);
25252     } catch (std::out_of_range& e) {
25253       {
25254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25255       };
25256     } catch (std::exception& e) {
25257       {
25258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25259       };
25260     } catch (...) {
25261       {
25262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25263       };
25264     }
25265   }
25266 }
25267
25268
25269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25270   void * jresult ;
25271   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25272   Dali::FrameBuffer result;
25273
25274   arg1 = (Dali::RenderTask *)jarg1;
25275   {
25276     try {
25277       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25278     } catch (std::out_of_range& e) {
25279       {
25280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25281       };
25282     } catch (std::exception& e) {
25283       {
25284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25285       };
25286     } catch (...) {
25287       {
25288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25289       };
25290     }
25291   }
25292   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25293   return jresult;
25294 }
25295
25296
25297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25298   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25299   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25300
25301   arg1 = (Dali::RenderTask *)jarg1;
25302   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25303   {
25304     try {
25305       (arg1)->SetScreenToFrameBufferFunction(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25313       };
25314     } catch (...) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25317       };
25318     }
25319   }
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25324   void * jresult ;
25325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25326   Dali::RenderTask::ScreenToFrameBufferFunction result;
25327
25328   arg1 = (Dali::RenderTask *)jarg1;
25329   {
25330     try {
25331       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (...) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25343       };
25344     }
25345   }
25346   jresult = (void *)result;
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25353   Dali::Actor arg2 ;
25354   Dali::Actor *argp2 ;
25355
25356   arg1 = (Dali::RenderTask *)jarg1;
25357   argp2 = (Dali::Actor *)jarg2;
25358   if (!argp2) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25360     return ;
25361   }
25362   arg2 = *argp2;
25363   {
25364     try {
25365       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25373       };
25374     } catch (...) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25377       };
25378     }
25379   }
25380 }
25381
25382
25383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25384   void * jresult ;
25385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25386   Dali::Actor result;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   {
25390     try {
25391       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25392     } catch (std::out_of_range& e) {
25393       {
25394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25395       };
25396     } catch (std::exception& e) {
25397       {
25398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (...) {
25401       {
25402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25403       };
25404     }
25405   }
25406   jresult = new Dali::Actor((const Dali::Actor &)result);
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25413   Dali::Vector2 arg2 ;
25414   Dali::Vector2 *argp2 ;
25415
25416   arg1 = (Dali::RenderTask *)jarg1;
25417   argp2 = (Dali::Vector2 *)jarg2;
25418   if (!argp2) {
25419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25420     return ;
25421   }
25422   arg2 = *argp2;
25423   {
25424     try {
25425       (arg1)->SetViewportPosition(arg2);
25426     } catch (std::out_of_range& e) {
25427       {
25428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (std::exception& e) {
25431       {
25432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25444   void * jresult ;
25445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25446   Dali::Vector2 result;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   {
25450     try {
25451       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25473   Dali::Vector2 arg2 ;
25474   Dali::Vector2 *argp2 ;
25475
25476   arg1 = (Dali::RenderTask *)jarg1;
25477   argp2 = (Dali::Vector2 *)jarg2;
25478   if (!argp2) {
25479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25480     return ;
25481   }
25482   arg2 = *argp2;
25483   {
25484     try {
25485       (arg1)->SetViewportSize(arg2);
25486     } catch (std::out_of_range& e) {
25487       {
25488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25489       };
25490     } catch (std::exception& e) {
25491       {
25492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25497       };
25498     }
25499   }
25500 }
25501
25502
25503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25504   void * jresult ;
25505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25506   Dali::Vector2 result;
25507
25508   arg1 = (Dali::RenderTask *)jarg1;
25509   {
25510     try {
25511       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25527   return jresult;
25528 }
25529
25530
25531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25533   Dali::Viewport arg2 ;
25534   Dali::Viewport *argp2 ;
25535
25536   arg1 = (Dali::RenderTask *)jarg1;
25537   argp2 = (Dali::Viewport *)jarg2;
25538   if (!argp2) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25540     return ;
25541   }
25542   arg2 = *argp2;
25543   {
25544     try {
25545       (arg1)->SetViewport(arg2);
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25553       };
25554     } catch (...) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25557       };
25558     }
25559   }
25560 }
25561
25562
25563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25564   void * jresult ;
25565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25566   Dali::Viewport result;
25567
25568   arg1 = (Dali::RenderTask *)jarg1;
25569   {
25570     try {
25571       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25572     } catch (std::out_of_range& e) {
25573       {
25574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25575       };
25576     } catch (std::exception& e) {
25577       {
25578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25579       };
25580     } catch (...) {
25581       {
25582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25583       };
25584     }
25585   }
25586   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25587   return jresult;
25588 }
25589
25590
25591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25592   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25593   Dali::Vector4 *arg2 = 0 ;
25594
25595   arg1 = (Dali::RenderTask *)jarg1;
25596   arg2 = (Dali::Vector4 *)jarg2;
25597   if (!arg2) {
25598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25599     return ;
25600   }
25601   {
25602     try {
25603       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25611       };
25612     } catch (...) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25615       };
25616     }
25617   }
25618 }
25619
25620
25621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25622   void * jresult ;
25623   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25624   Dali::Vector4 result;
25625
25626   arg1 = (Dali::RenderTask *)jarg1;
25627   {
25628     try {
25629       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25630     } catch (std::out_of_range& e) {
25631       {
25632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25633       };
25634     } catch (std::exception& e) {
25635       {
25636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25637       };
25638     } catch (...) {
25639       {
25640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25641       };
25642     }
25643   }
25644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25645   return jresult;
25646 }
25647
25648
25649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25650   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25651   bool arg2 ;
25652
25653   arg1 = (Dali::RenderTask *)jarg1;
25654   arg2 = jarg2 ? true : false;
25655   {
25656     try {
25657       (arg1)->SetClearEnabled(arg2);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (...) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25669       };
25670     }
25671   }
25672 }
25673
25674
25675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25676   unsigned int jresult ;
25677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25678   bool result;
25679
25680   arg1 = (Dali::RenderTask *)jarg1;
25681   {
25682     try {
25683       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25684     } catch (std::out_of_range& e) {
25685       {
25686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25687       };
25688     } catch (std::exception& e) {
25689       {
25690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25691       };
25692     } catch (...) {
25693       {
25694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25695       };
25696     }
25697   }
25698   jresult = result;
25699   return jresult;
25700 }
25701
25702
25703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25704   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25705   bool arg2 ;
25706
25707   arg1 = (Dali::RenderTask *)jarg1;
25708   arg2 = jarg2 ? true : false;
25709   {
25710     try {
25711       (arg1)->SetCullMode(arg2);
25712     } catch (std::out_of_range& e) {
25713       {
25714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25715       };
25716     } catch (std::exception& e) {
25717       {
25718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25719       };
25720     } catch (...) {
25721       {
25722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25723       };
25724     }
25725   }
25726 }
25727
25728
25729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25730   unsigned int jresult ;
25731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25732   bool result;
25733
25734   arg1 = (Dali::RenderTask *)jarg1;
25735   {
25736     try {
25737       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25738     } catch (std::out_of_range& e) {
25739       {
25740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25741       };
25742     } catch (std::exception& e) {
25743       {
25744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25745       };
25746     } catch (...) {
25747       {
25748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25749       };
25750     }
25751   }
25752   jresult = result;
25753   return jresult;
25754 }
25755
25756
25757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25758   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25759   unsigned int arg2 ;
25760
25761   arg1 = (Dali::RenderTask *)jarg1;
25762   arg2 = (unsigned int)jarg2;
25763   {
25764     try {
25765       (arg1)->SetRefreshRate(arg2);
25766     } catch (std::out_of_range& e) {
25767       {
25768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25769       };
25770     } catch (std::exception& e) {
25771       {
25772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25773       };
25774     } catch (...) {
25775       {
25776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25777       };
25778     }
25779   }
25780 }
25781
25782
25783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25784   unsigned int jresult ;
25785   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25786   unsigned int result;
25787
25788   arg1 = (Dali::RenderTask *)jarg1;
25789   {
25790     try {
25791       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25792     } catch (std::out_of_range& e) {
25793       {
25794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25795       };
25796     } catch (std::exception& e) {
25797       {
25798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (...) {
25801       {
25802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25803       };
25804     }
25805   }
25806   jresult = result;
25807   return jresult;
25808 }
25809
25810
25811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25812   unsigned int jresult ;
25813   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25814   Dali::Vector3 *arg2 = 0 ;
25815   float *arg3 = 0 ;
25816   float *arg4 = 0 ;
25817   bool result;
25818
25819   arg1 = (Dali::RenderTask *)jarg1;
25820   arg2 = (Dali::Vector3 *)jarg2;
25821   if (!arg2) {
25822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25823     return 0;
25824   }
25825   arg3 = (float *)jarg3;
25826   arg4 = (float *)jarg4;
25827   {
25828     try {
25829       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25830     } catch (std::out_of_range& e) {
25831       {
25832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25833       };
25834     } catch (std::exception& e) {
25835       {
25836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25837       };
25838     } catch (...) {
25839       {
25840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25841       };
25842     }
25843   }
25844   jresult = result;
25845   return jresult;
25846 }
25847
25848
25849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25850   unsigned int jresult ;
25851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25852   Dali::Actor arg2 ;
25853   float arg3 ;
25854   float arg4 ;
25855   float *arg5 = 0 ;
25856   float *arg6 = 0 ;
25857   Dali::Actor *argp2 ;
25858   bool result;
25859
25860   arg1 = (Dali::RenderTask *)jarg1;
25861   argp2 = (Dali::Actor *)jarg2;
25862   if (!argp2) {
25863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25864     return 0;
25865   }
25866   arg2 = *argp2;
25867   arg3 = (float)jarg3;
25868   arg4 = (float)jarg4;
25869   arg5 = (float *)jarg5;
25870   arg6 = (float *)jarg6;
25871   {
25872     try {
25873       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25874     } catch (std::out_of_range& e) {
25875       {
25876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25877       };
25878     } catch (std::exception& e) {
25879       {
25880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (...) {
25883       {
25884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25885       };
25886     }
25887   }
25888   jresult = result;
25889   return jresult;
25890 }
25891
25892
25893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25894   void * jresult ;
25895   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25896   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25897
25898   arg1 = (Dali::RenderTask *)jarg1;
25899   {
25900     try {
25901       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25902     } catch (std::out_of_range& e) {
25903       {
25904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25905       };
25906     } catch (std::exception& e) {
25907       {
25908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25909       };
25910     } catch (...) {
25911       {
25912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25913       };
25914     }
25915   }
25916   jresult = (void *)result;
25917   return jresult;
25918 }
25919
25920
25921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25922   void * jresult ;
25923   int arg1 ;
25924   Dali::TouchPoint::State arg2 ;
25925   float arg3 ;
25926   float arg4 ;
25927   Dali::TouchPoint *result = 0 ;
25928
25929   arg1 = (int)jarg1;
25930   arg2 = (Dali::TouchPoint::State)jarg2;
25931   arg3 = (float)jarg3;
25932   arg4 = (float)jarg4;
25933   {
25934     try {
25935       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25936     } catch (std::out_of_range& e) {
25937       {
25938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (std::exception& e) {
25941       {
25942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25943       };
25944     } catch (...) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25947       };
25948     }
25949   }
25950   jresult = (void *)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25956   void * jresult ;
25957   int arg1 ;
25958   Dali::TouchPoint::State arg2 ;
25959   float arg3 ;
25960   float arg4 ;
25961   float arg5 ;
25962   float arg6 ;
25963   Dali::TouchPoint *result = 0 ;
25964
25965   arg1 = (int)jarg1;
25966   arg2 = (Dali::TouchPoint::State)jarg2;
25967   arg3 = (float)jarg3;
25968   arg4 = (float)jarg4;
25969   arg5 = (float)jarg5;
25970   arg6 = (float)jarg6;
25971   {
25972     try {
25973       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25974     } catch (std::out_of_range& e) {
25975       {
25976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25977       };
25978     } catch (std::exception& e) {
25979       {
25980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25981       };
25982     } catch (...) {
25983       {
25984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25985       };
25986     }
25987   }
25988   jresult = (void *)result;
25989   return jresult;
25990 }
25991
25992
25993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25994   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25995
25996   arg1 = (Dali::TouchPoint *)jarg1;
25997   {
25998     try {
25999       delete arg1;
26000     } catch (std::out_of_range& e) {
26001       {
26002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (std::exception& e) {
26005       {
26006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (...) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26011       };
26012     }
26013   }
26014 }
26015
26016
26017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26018   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26019   int arg2 ;
26020
26021   arg1 = (Dali::TouchPoint *)jarg1;
26022   arg2 = (int)jarg2;
26023   if (arg1) (arg1)->deviceId = arg2;
26024 }
26025
26026
26027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26028   int jresult ;
26029   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26030   int result;
26031
26032   arg1 = (Dali::TouchPoint *)jarg1;
26033   result = (int) ((arg1)->deviceId);
26034   jresult = result;
26035   return jresult;
26036 }
26037
26038
26039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26040   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26041   Dali::TouchPoint::State arg2 ;
26042
26043   arg1 = (Dali::TouchPoint *)jarg1;
26044   arg2 = (Dali::TouchPoint::State)jarg2;
26045   if (arg1) (arg1)->state = arg2;
26046 }
26047
26048
26049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26050   int jresult ;
26051   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26052   Dali::TouchPoint::State result;
26053
26054   arg1 = (Dali::TouchPoint *)jarg1;
26055   result = (Dali::TouchPoint::State) ((arg1)->state);
26056   jresult = (int)result;
26057   return jresult;
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26062   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26063   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26064
26065   arg1 = (Dali::TouchPoint *)jarg1;
26066   arg2 = (Dali::Actor *)jarg2;
26067   if (arg1) (arg1)->hitActor = *arg2;
26068 }
26069
26070
26071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26072   void * jresult ;
26073   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26074   Dali::Actor *result = 0 ;
26075
26076   arg1 = (Dali::TouchPoint *)jarg1;
26077   result = (Dali::Actor *)& ((arg1)->hitActor);
26078   jresult = (void *)result;
26079   return jresult;
26080 }
26081
26082
26083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26084   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26085   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26086
26087   arg1 = (Dali::TouchPoint *)jarg1;
26088   arg2 = (Dali::Vector2 *)jarg2;
26089   if (arg1) (arg1)->local = *arg2;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26094   void * jresult ;
26095   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26096   Dali::Vector2 *result = 0 ;
26097
26098   arg1 = (Dali::TouchPoint *)jarg1;
26099   result = (Dali::Vector2 *)& ((arg1)->local);
26100   jresult = (void *)result;
26101   return jresult;
26102 }
26103
26104
26105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26106   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26107   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26108
26109   arg1 = (Dali::TouchPoint *)jarg1;
26110   arg2 = (Dali::Vector2 *)jarg2;
26111   if (arg1) (arg1)->screen = *arg2;
26112 }
26113
26114
26115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26116   void * jresult ;
26117   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26118   Dali::Vector2 *result = 0 ;
26119
26120   arg1 = (Dali::TouchPoint *)jarg1;
26121   result = (Dali::Vector2 *)& ((arg1)->screen);
26122   jresult = (void *)result;
26123   return jresult;
26124 }
26125
26126
26127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26128   void * jresult ;
26129   Dali::TouchData *result = 0 ;
26130
26131   {
26132     try {
26133       result = (Dali::TouchData *)new Dali::TouchData();
26134     } catch (std::out_of_range& e) {
26135       {
26136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26137       };
26138     } catch (std::exception& e) {
26139       {
26140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26141       };
26142     } catch (...) {
26143       {
26144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26145       };
26146     }
26147   }
26148   jresult = (void *)result;
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26154   void * jresult ;
26155   Dali::TouchData *arg1 = 0 ;
26156   Dali::TouchData *result = 0 ;
26157
26158   arg1 = (Dali::TouchData *)jarg1;
26159   if (!arg1) {
26160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26161     return 0;
26162   }
26163   {
26164     try {
26165       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26166     } catch (std::out_of_range& e) {
26167       {
26168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26169       };
26170     } catch (std::exception& e) {
26171       {
26172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26173       };
26174     } catch (...) {
26175       {
26176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26177       };
26178     }
26179   }
26180   jresult = (void *)result;
26181   return jresult;
26182 }
26183
26184
26185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26186   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26187
26188   arg1 = (Dali::TouchData *)jarg1;
26189   {
26190     try {
26191       delete arg1;
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26203       };
26204     }
26205   }
26206 }
26207
26208
26209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26210   void * jresult ;
26211   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26212   Dali::TouchData *arg2 = 0 ;
26213   Dali::TouchData *result = 0 ;
26214
26215   arg1 = (Dali::TouchData *)jarg1;
26216   arg2 = (Dali::TouchData *)jarg2;
26217   if (!arg2) {
26218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26219     return 0;
26220   }
26221   {
26222     try {
26223       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26224     } catch (std::out_of_range& e) {
26225       {
26226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26227       };
26228     } catch (std::exception& e) {
26229       {
26230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26231       };
26232     } catch (...) {
26233       {
26234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26235       };
26236     }
26237   }
26238   jresult = (void *)result;
26239   return jresult;
26240 }
26241
26242
26243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26244   unsigned long jresult ;
26245   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26246   unsigned long result;
26247
26248   arg1 = (Dali::TouchData *)jarg1;
26249   {
26250     try {
26251       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26252     } catch (std::out_of_range& e) {
26253       {
26254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26255       };
26256     } catch (std::exception& e) {
26257       {
26258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26259       };
26260     } catch (...) {
26261       {
26262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26263       };
26264     }
26265   }
26266   jresult = (unsigned long)result;
26267   return jresult;
26268 }
26269
26270
26271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26272   unsigned long jresult ;
26273   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26274   std::size_t result;
26275
26276   arg1 = (Dali::TouchData *)jarg1;
26277   {
26278     try {
26279       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26280     } catch (std::out_of_range& e) {
26281       {
26282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (std::exception& e) {
26285       {
26286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294   jresult = (unsigned long)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26300   int jresult ;
26301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26302   std::size_t arg2 ;
26303   int32_t result;
26304
26305   arg1 = (Dali::TouchData *)jarg1;
26306   arg2 = (std::size_t)jarg2;
26307   {
26308     try {
26309       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26310     } catch (std::out_of_range& e) {
26311       {
26312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26313       };
26314     } catch (std::exception& e) {
26315       {
26316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26317       };
26318     } catch (...) {
26319       {
26320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26321       };
26322     }
26323   }
26324   jresult = result;
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26330   int jresult ;
26331   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26332   std::size_t arg2 ;
26333   Dali::PointState::Type result;
26334
26335   arg1 = (Dali::TouchData *)jarg1;
26336   arg2 = (std::size_t)jarg2;
26337   {
26338     try {
26339       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26340     } catch (std::out_of_range& e) {
26341       {
26342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (std::exception& e) {
26345       {
26346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354   jresult = (int)result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26360   void * jresult ;
26361   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26362   std::size_t arg2 ;
26363   Dali::Actor result;
26364
26365   arg1 = (Dali::TouchData *)jarg1;
26366   arg2 = (std::size_t)jarg2;
26367   {
26368     try {
26369       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26370     } catch (std::out_of_range& e) {
26371       {
26372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (std::exception& e) {
26375       {
26376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384   jresult = new Dali::Actor((const Dali::Actor &)result);
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26390   void * jresult ;
26391   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26392   std::size_t arg2 ;
26393   Dali::Vector2 *result = 0 ;
26394
26395   arg1 = (Dali::TouchData *)jarg1;
26396   arg2 = (std::size_t)jarg2;
26397   {
26398     try {
26399       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26400     } catch (std::out_of_range& e) {
26401       {
26402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (std::exception& e) {
26405       {
26406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414   jresult = (void *)result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26420   void * jresult ;
26421   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26422   std::size_t arg2 ;
26423   Dali::Vector2 *result = 0 ;
26424
26425   arg1 = (Dali::TouchData *)jarg1;
26426   arg2 = (std::size_t)jarg2;
26427   {
26428     try {
26429       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (...) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26441       };
26442     }
26443   }
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26450   float jresult ;
26451   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26452   std::size_t arg2 ;
26453   float result;
26454
26455   arg1 = (Dali::TouchData *)jarg1;
26456   arg2 = (std::size_t)jarg2;
26457   {
26458     try {
26459       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26460     } catch (std::out_of_range& e) {
26461       {
26462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26463       };
26464     } catch (std::exception& e) {
26465       {
26466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (...) {
26469       {
26470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26471       };
26472     }
26473   }
26474   jresult = result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26480   void * jresult ;
26481   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26482   std::size_t arg2 ;
26483   Dali::Vector2 *result = 0 ;
26484
26485   arg1 = (Dali::TouchData *)jarg1;
26486   arg2 = (std::size_t)jarg2;
26487   {
26488     try {
26489       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (...) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26501       };
26502     }
26503   }
26504   jresult = (void *)result;
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26510   float jresult ;
26511   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26512   std::size_t arg2 ;
26513   float result;
26514
26515   arg1 = (Dali::TouchData *)jarg1;
26516   arg2 = (std::size_t)jarg2;
26517   {
26518     try {
26519       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26520     } catch (std::out_of_range& e) {
26521       {
26522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26523       };
26524     } catch (std::exception& e) {
26525       {
26526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26527       };
26528     } catch (...) {
26529       {
26530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26531       };
26532     }
26533   }
26534   jresult = result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26540   void * jresult ;
26541   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26542   std::size_t arg2 ;
26543   Dali::Degree result;
26544
26545   arg1 = (Dali::TouchData *)jarg1;
26546   arg2 = (std::size_t)jarg2;
26547   {
26548     try {
26549       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26550     } catch (std::out_of_range& e) {
26551       {
26552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26553       };
26554     } catch (std::exception& e) {
26555       {
26556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26557       };
26558     } catch (...) {
26559       {
26560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26561       };
26562     }
26563   }
26564   jresult = new Dali::Degree((const Dali::Degree &)result);
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26570   void * jresult ;
26571   Dali::GestureDetector *result = 0 ;
26572
26573   {
26574     try {
26575       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26576     } catch (std::out_of_range& e) {
26577       {
26578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26579       };
26580     } catch (std::exception& e) {
26581       {
26582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26583       };
26584     } catch (...) {
26585       {
26586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26587       };
26588     }
26589   }
26590   jresult = (void *)result;
26591   return jresult;
26592 }
26593
26594
26595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26596   void * jresult ;
26597   Dali::BaseHandle arg1 ;
26598   Dali::BaseHandle *argp1 ;
26599   Dali::GestureDetector result;
26600
26601   argp1 = (Dali::BaseHandle *)jarg1;
26602   if (!argp1) {
26603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26604     return 0;
26605   }
26606   arg1 = *argp1;
26607   {
26608     try {
26609       result = Dali::GestureDetector::DownCast(arg1);
26610     } catch (std::out_of_range& e) {
26611       {
26612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26613       };
26614     } catch (std::exception& e) {
26615       {
26616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26617       };
26618     } catch (...) {
26619       {
26620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26621       };
26622     }
26623   }
26624   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26625   return jresult;
26626 }
26627
26628
26629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26630   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26631
26632   arg1 = (Dali::GestureDetector *)jarg1;
26633   {
26634     try {
26635       delete arg1;
26636     } catch (std::out_of_range& e) {
26637       {
26638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26639       };
26640     } catch (std::exception& e) {
26641       {
26642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26643       };
26644     } catch (...) {
26645       {
26646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26647       };
26648     }
26649   }
26650 }
26651
26652
26653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26654   void * jresult ;
26655   Dali::GestureDetector *arg1 = 0 ;
26656   Dali::GestureDetector *result = 0 ;
26657
26658   arg1 = (Dali::GestureDetector *)jarg1;
26659   if (!arg1) {
26660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26661     return 0;
26662   }
26663   {
26664     try {
26665       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26666     } catch (std::out_of_range& e) {
26667       {
26668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26669       };
26670     } catch (std::exception& e) {
26671       {
26672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26673       };
26674     } catch (...) {
26675       {
26676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26677       };
26678     }
26679   }
26680   jresult = (void *)result;
26681   return jresult;
26682 }
26683
26684
26685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26686   void * jresult ;
26687   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26688   Dali::GestureDetector *arg2 = 0 ;
26689   Dali::GestureDetector *result = 0 ;
26690
26691   arg1 = (Dali::GestureDetector *)jarg1;
26692   arg2 = (Dali::GestureDetector *)jarg2;
26693   if (!arg2) {
26694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26695     return 0;
26696   }
26697   {
26698     try {
26699       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26700     } catch (std::out_of_range& e) {
26701       {
26702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26703       };
26704     } catch (std::exception& e) {
26705       {
26706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26707       };
26708     } catch (...) {
26709       {
26710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26711       };
26712     }
26713   }
26714   jresult = (void *)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26720   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26721   Dali::Actor arg2 ;
26722   Dali::Actor *argp2 ;
26723
26724   arg1 = (Dali::GestureDetector *)jarg1;
26725   argp2 = (Dali::Actor *)jarg2;
26726   if (!argp2) {
26727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26728     return ;
26729   }
26730   arg2 = *argp2;
26731   {
26732     try {
26733       (arg1)->Attach(arg2);
26734     } catch (std::out_of_range& e) {
26735       {
26736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (std::exception& e) {
26739       {
26740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26741       };
26742     } catch (...) {
26743       {
26744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26745       };
26746     }
26747   }
26748 }
26749
26750
26751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26752   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26753   Dali::Actor arg2 ;
26754   Dali::Actor *argp2 ;
26755
26756   arg1 = (Dali::GestureDetector *)jarg1;
26757   argp2 = (Dali::Actor *)jarg2;
26758   if (!argp2) {
26759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26760     return ;
26761   }
26762   arg2 = *argp2;
26763   {
26764     try {
26765       (arg1)->Detach(arg2);
26766     } catch (std::out_of_range& e) {
26767       {
26768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26769       };
26770     } catch (std::exception& e) {
26771       {
26772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26773       };
26774     } catch (...) {
26775       {
26776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26777       };
26778     }
26779   }
26780 }
26781
26782
26783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26784   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26785
26786   arg1 = (Dali::GestureDetector *)jarg1;
26787   {
26788     try {
26789       (arg1)->DetachAll();
26790     } catch (std::out_of_range& e) {
26791       {
26792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26793       };
26794     } catch (std::exception& e) {
26795       {
26796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26797       };
26798     } catch (...) {
26799       {
26800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26801       };
26802     }
26803   }
26804 }
26805
26806
26807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26808   unsigned long jresult ;
26809   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26810   size_t result;
26811
26812   arg1 = (Dali::GestureDetector *)jarg1;
26813   {
26814     try {
26815       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26816     } catch (std::out_of_range& e) {
26817       {
26818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26819       };
26820     } catch (std::exception& e) {
26821       {
26822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26823       };
26824     } catch (...) {
26825       {
26826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26827       };
26828     }
26829   }
26830   jresult = (unsigned long)result;
26831   return jresult;
26832 }
26833
26834
26835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26836   void * jresult ;
26837   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26838   size_t arg2 ;
26839   Dali::Actor result;
26840
26841   arg1 = (Dali::GestureDetector *)jarg1;
26842   arg2 = (size_t)jarg2;
26843   {
26844     try {
26845       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26846     } catch (std::out_of_range& e) {
26847       {
26848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26849       };
26850     } catch (std::exception& e) {
26851       {
26852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (...) {
26855       {
26856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26857       };
26858     }
26859   }
26860   jresult = new Dali::Actor((const Dali::Actor &)result);
26861   return jresult;
26862 }
26863
26864
26865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26866   void * jresult ;
26867   Dali::Gesture *arg1 = 0 ;
26868   Dali::Gesture *result = 0 ;
26869
26870   arg1 = (Dali::Gesture *)jarg1;
26871   if (!arg1) {
26872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26873     return 0;
26874   }
26875   {
26876     try {
26877       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26878     } catch (std::out_of_range& e) {
26879       {
26880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26881       };
26882     } catch (std::exception& e) {
26883       {
26884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26889       };
26890     }
26891   }
26892   jresult = (void *)result;
26893   return jresult;
26894 }
26895
26896
26897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26898   void * jresult ;
26899   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26900   Dali::Gesture *arg2 = 0 ;
26901   Dali::Gesture *result = 0 ;
26902
26903   arg1 = (Dali::Gesture *)jarg1;
26904   arg2 = (Dali::Gesture *)jarg2;
26905   if (!arg2) {
26906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26907     return 0;
26908   }
26909   {
26910     try {
26911       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26912     } catch (std::out_of_range& e) {
26913       {
26914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26915       };
26916     } catch (std::exception& e) {
26917       {
26918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26919       };
26920     } catch (...) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26923       };
26924     }
26925   }
26926   jresult = (void *)result;
26927   return jresult;
26928 }
26929
26930
26931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26932   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26933
26934   arg1 = (Dali::Gesture *)jarg1;
26935   {
26936     try {
26937       delete arg1;
26938     } catch (std::out_of_range& e) {
26939       {
26940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26941       };
26942     } catch (std::exception& e) {
26943       {
26944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26949       };
26950     }
26951   }
26952 }
26953
26954
26955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26956   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26957   Dali::Gesture::Type arg2 ;
26958
26959   arg1 = (Dali::Gesture *)jarg1;
26960   arg2 = (Dali::Gesture::Type)jarg2;
26961   if (arg1) (arg1)->type = arg2;
26962 }
26963
26964
26965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26966   int jresult ;
26967   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26968   Dali::Gesture::Type result;
26969
26970   arg1 = (Dali::Gesture *)jarg1;
26971   result = (Dali::Gesture::Type) ((arg1)->type);
26972   jresult = (int)result;
26973   return jresult;
26974 }
26975
26976
26977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26978   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26979   Dali::Gesture::State arg2 ;
26980
26981   arg1 = (Dali::Gesture *)jarg1;
26982   arg2 = (Dali::Gesture::State)jarg2;
26983   if (arg1) (arg1)->state = arg2;
26984 }
26985
26986
26987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26988   int jresult ;
26989   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26990   Dali::Gesture::State result;
26991
26992   arg1 = (Dali::Gesture *)jarg1;
26993   result = (Dali::Gesture::State) ((arg1)->state);
26994   jresult = (int)result;
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27000   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27001   unsigned int arg2 ;
27002
27003   arg1 = (Dali::Gesture *)jarg1;
27004   arg2 = (unsigned int)jarg2;
27005   if (arg1) (arg1)->time = arg2;
27006 }
27007
27008
27009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27010   unsigned int jresult ;
27011   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27012   unsigned int result;
27013
27014   arg1 = (Dali::Gesture *)jarg1;
27015   result = (unsigned int) ((arg1)->time);
27016   jresult = result;
27017   return jresult;
27018 }
27019
27020
27021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27022   void * jresult ;
27023   Dali::HoverEvent *result = 0 ;
27024
27025   {
27026     try {
27027       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27028     } catch (std::out_of_range& e) {
27029       {
27030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (std::exception& e) {
27033       {
27034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042   jresult = (void *)result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27048   void * jresult ;
27049   unsigned long arg1 ;
27050   Dali::HoverEvent *result = 0 ;
27051
27052   arg1 = (unsigned long)jarg1;
27053   {
27054     try {
27055       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27056     } catch (std::out_of_range& e) {
27057       {
27058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27059       };
27060     } catch (std::exception& e) {
27061       {
27062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27063       };
27064     } catch (...) {
27065       {
27066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27067       };
27068     }
27069   }
27070   jresult = (void *)result;
27071   return jresult;
27072 }
27073
27074
27075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27076   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27077
27078   arg1 = (Dali::HoverEvent *)jarg1;
27079   {
27080     try {
27081       delete arg1;
27082     } catch (std::out_of_range& e) {
27083       {
27084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27085       };
27086     } catch (std::exception& e) {
27087       {
27088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27093       };
27094     }
27095   }
27096 }
27097
27098
27099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27100   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27101   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27102
27103   arg1 = (Dali::HoverEvent *)jarg1;
27104   arg2 = (Dali::TouchPointContainer *)jarg2;
27105   if (arg1) (arg1)->points = *arg2;
27106 }
27107
27108
27109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27110   void * jresult ;
27111   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27112   Dali::TouchPointContainer *result = 0 ;
27113
27114   arg1 = (Dali::HoverEvent *)jarg1;
27115   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27116   jresult = (void *)result;
27117   return jresult;
27118 }
27119
27120
27121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27122   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27123   unsigned long arg2 ;
27124
27125   arg1 = (Dali::HoverEvent *)jarg1;
27126   arg2 = (unsigned long)jarg2;
27127   if (arg1) (arg1)->time = arg2;
27128 }
27129
27130
27131 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27132   unsigned long jresult ;
27133   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27134   unsigned long result;
27135
27136   arg1 = (Dali::HoverEvent *)jarg1;
27137   result = (unsigned long) ((arg1)->time);
27138   jresult = (unsigned long)result;
27139   return jresult;
27140 }
27141
27142
27143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27144   unsigned int jresult ;
27145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27146   unsigned int result;
27147
27148   arg1 = (Dali::HoverEvent *)jarg1;
27149   {
27150     try {
27151       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27152     } catch (std::out_of_range& e) {
27153       {
27154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (std::exception& e) {
27157       {
27158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (...) {
27161       {
27162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27163       };
27164     }
27165   }
27166   jresult = result;
27167   return jresult;
27168 }
27169
27170
27171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27172   void * jresult ;
27173   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27174   unsigned int arg2 ;
27175   Dali::TouchPoint *result = 0 ;
27176
27177   arg1 = (Dali::HoverEvent *)jarg1;
27178   arg2 = (unsigned int)jarg2;
27179   {
27180     try {
27181       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27182     } catch (std::out_of_range& e) {
27183       {
27184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27185       };
27186     } catch (std::exception& e) {
27187       {
27188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27189       };
27190     } catch (...) {
27191       {
27192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27193       };
27194     }
27195   }
27196   jresult = (void *)result;
27197   return jresult;
27198 }
27199
27200
27201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27202   void * jresult ;
27203   Dali::KeyEvent *result = 0 ;
27204
27205   {
27206     try {
27207       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27208     } catch (std::out_of_range& e) {
27209       {
27210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27211       };
27212     } catch (std::exception& e) {
27213       {
27214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27215       };
27216     } catch (...) {
27217       {
27218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27219       };
27220     }
27221   }
27222   jresult = (void *)result;
27223   return jresult;
27224 }
27225
27226
27227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27228   void * jresult ;
27229   std::string *arg1 = 0 ;
27230   std::string *arg2 = 0 ;
27231   int arg3 ;
27232   int arg4 ;
27233   unsigned long arg5 ;
27234   Dali::KeyEvent::State *arg6 = 0 ;
27235   Dali::KeyEvent::State temp6 ;
27236   Dali::KeyEvent *result = 0 ;
27237
27238   if (!jarg1) {
27239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27240     return 0;
27241   }
27242   std::string arg1_str(jarg1);
27243   arg1 = &arg1_str;
27244   if (!jarg2) {
27245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27246     return 0;
27247   }
27248   std::string arg2_str(jarg2);
27249   arg2 = &arg2_str;
27250   arg3 = (int)jarg3;
27251   arg4 = (int)jarg4;
27252   arg5 = (unsigned long)jarg5;
27253   temp6 = (Dali::KeyEvent::State)jarg6;
27254   arg6 = &temp6;
27255   {
27256     try {
27257       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27258     } catch (std::out_of_range& e) {
27259       {
27260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27261       };
27262     } catch (std::exception& e) {
27263       {
27264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (...) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27269       };
27270     }
27271   }
27272   jresult = (void *)result;
27273
27274   //argout typemap for const std::string&
27275
27276
27277   //argout typemap for const std::string&
27278
27279   return jresult;
27280 }
27281
27282
27283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27284   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27285
27286   arg1 = (Dali::KeyEvent *)jarg1;
27287   {
27288     try {
27289       delete arg1;
27290     } catch (std::out_of_range& e) {
27291       {
27292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27293       };
27294     } catch (std::exception& e) {
27295       {
27296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27301       };
27302     }
27303   }
27304 }
27305
27306
27307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27308   unsigned int jresult ;
27309   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27310   bool result;
27311
27312   arg1 = (Dali::KeyEvent *)jarg1;
27313   {
27314     try {
27315       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27316     } catch (std::out_of_range& e) {
27317       {
27318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27319       };
27320     } catch (std::exception& e) {
27321       {
27322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27323       };
27324     } catch (...) {
27325       {
27326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27327       };
27328     }
27329   }
27330   jresult = result;
27331   return jresult;
27332 }
27333
27334
27335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27336   unsigned int jresult ;
27337   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27338   bool result;
27339
27340   arg1 = (Dali::KeyEvent *)jarg1;
27341   {
27342     try {
27343       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27344     } catch (std::out_of_range& e) {
27345       {
27346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27347       };
27348     } catch (std::exception& e) {
27349       {
27350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27351       };
27352     } catch (...) {
27353       {
27354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27355       };
27356     }
27357   }
27358   jresult = result;
27359   return jresult;
27360 }
27361
27362
27363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27364   unsigned int jresult ;
27365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27366   bool result;
27367
27368   arg1 = (Dali::KeyEvent *)jarg1;
27369   {
27370     try {
27371       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27372     } catch (std::out_of_range& e) {
27373       {
27374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27375       };
27376     } catch (std::exception& e) {
27377       {
27378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27379       };
27380     } catch (...) {
27381       {
27382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27383       };
27384     }
27385   }
27386   jresult = result;
27387   return jresult;
27388 }
27389
27390
27391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27392   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27393   std::string *arg2 = 0 ;
27394
27395   arg1 = (Dali::KeyEvent *)jarg1;
27396   if (!jarg2) {
27397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27398     return ;
27399   }
27400   std::string arg2_str(jarg2);
27401   arg2 = &arg2_str;
27402   if (arg1) (arg1)->keyPressedName = *arg2;
27403
27404   //argout typemap for const std::string&
27405
27406 }
27407
27408
27409 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27410   char * jresult ;
27411   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27412   std::string *result = 0 ;
27413
27414   arg1 = (Dali::KeyEvent *)jarg1;
27415   result = (std::string *) & ((arg1)->keyPressedName);
27416   jresult = SWIG_csharp_string_callback(result->c_str());
27417   return jresult;
27418 }
27419
27420
27421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27422   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27423   std::string *arg2 = 0 ;
27424
27425   arg1 = (Dali::KeyEvent *)jarg1;
27426   if (!jarg2) {
27427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27428     return ;
27429   }
27430   std::string arg2_str(jarg2);
27431   arg2 = &arg2_str;
27432   if (arg1) (arg1)->keyPressed = *arg2;
27433
27434   //argout typemap for const std::string&
27435
27436 }
27437
27438
27439 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27440   char * jresult ;
27441   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27442   std::string *result = 0 ;
27443
27444   arg1 = (Dali::KeyEvent *)jarg1;
27445   result = (std::string *) & ((arg1)->keyPressed);
27446   jresult = SWIG_csharp_string_callback(result->c_str());
27447   return jresult;
27448 }
27449
27450
27451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27453   int arg2 ;
27454
27455   arg1 = (Dali::KeyEvent *)jarg1;
27456   arg2 = (int)jarg2;
27457   if (arg1) (arg1)->keyCode = arg2;
27458 }
27459
27460
27461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27462   int jresult ;
27463   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27464   int result;
27465
27466   arg1 = (Dali::KeyEvent *)jarg1;
27467   result = (int) ((arg1)->keyCode);
27468   jresult = result;
27469   return jresult;
27470 }
27471
27472
27473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27474   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27475   int arg2 ;
27476
27477   arg1 = (Dali::KeyEvent *)jarg1;
27478   arg2 = (int)jarg2;
27479   if (arg1) (arg1)->keyModifier = arg2;
27480 }
27481
27482
27483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27484   int jresult ;
27485   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27486   int result;
27487
27488   arg1 = (Dali::KeyEvent *)jarg1;
27489   result = (int) ((arg1)->keyModifier);
27490   jresult = result;
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27496   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27497   unsigned long arg2 ;
27498
27499   arg1 = (Dali::KeyEvent *)jarg1;
27500   arg2 = (unsigned long)jarg2;
27501   if (arg1) (arg1)->time = arg2;
27502 }
27503
27504
27505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27506   unsigned long jresult ;
27507   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27508   unsigned long result;
27509
27510   arg1 = (Dali::KeyEvent *)jarg1;
27511   result = (unsigned long) ((arg1)->time);
27512   jresult = (unsigned long)result;
27513   return jresult;
27514 }
27515
27516
27517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27518   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27519   Dali::KeyEvent::State arg2 ;
27520
27521   arg1 = (Dali::KeyEvent *)jarg1;
27522   arg2 = (Dali::KeyEvent::State)jarg2;
27523   if (arg1) (arg1)->state = arg2;
27524 }
27525
27526
27527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27528   int jresult ;
27529   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27530   Dali::KeyEvent::State result;
27531
27532   arg1 = (Dali::KeyEvent *)jarg1;
27533   result = (Dali::KeyEvent::State) ((arg1)->state);
27534   jresult = (int)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27540   void * jresult ;
27541   Dali::LongPressGestureDetector *result = 0 ;
27542
27543   {
27544     try {
27545       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27546     } catch (std::out_of_range& e) {
27547       {
27548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27549       };
27550     } catch (std::exception& e) {
27551       {
27552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27553       };
27554     } catch (...) {
27555       {
27556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27557       };
27558     }
27559   }
27560   jresult = (void *)result;
27561   return jresult;
27562 }
27563
27564
27565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27566   void * jresult ;
27567   Dali::LongPressGestureDetector result;
27568
27569   {
27570     try {
27571       result = Dali::LongPressGestureDetector::New();
27572     } catch (std::out_of_range& e) {
27573       {
27574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27575       };
27576     } catch (std::exception& e) {
27577       {
27578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27579       };
27580     } catch (...) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27583       };
27584     }
27585   }
27586   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27587   return jresult;
27588 }
27589
27590
27591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27592   void * jresult ;
27593   unsigned int arg1 ;
27594   Dali::LongPressGestureDetector result;
27595
27596   arg1 = (unsigned int)jarg1;
27597   {
27598     try {
27599       result = Dali::LongPressGestureDetector::New(arg1);
27600     } catch (std::out_of_range& e) {
27601       {
27602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27603       };
27604     } catch (std::exception& e) {
27605       {
27606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27607       };
27608     } catch (...) {
27609       {
27610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27611       };
27612     }
27613   }
27614   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27615   return jresult;
27616 }
27617
27618
27619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27620   void * jresult ;
27621   unsigned int arg1 ;
27622   unsigned int arg2 ;
27623   Dali::LongPressGestureDetector result;
27624
27625   arg1 = (unsigned int)jarg1;
27626   arg2 = (unsigned int)jarg2;
27627   {
27628     try {
27629       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27630     } catch (std::out_of_range& e) {
27631       {
27632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27633       };
27634     } catch (std::exception& e) {
27635       {
27636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (...) {
27639       {
27640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27641       };
27642     }
27643   }
27644   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27645   return jresult;
27646 }
27647
27648
27649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27650   void * jresult ;
27651   Dali::BaseHandle arg1 ;
27652   Dali::BaseHandle *argp1 ;
27653   Dali::LongPressGestureDetector result;
27654
27655   argp1 = (Dali::BaseHandle *)jarg1;
27656   if (!argp1) {
27657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27658     return 0;
27659   }
27660   arg1 = *argp1;
27661   {
27662     try {
27663       result = Dali::LongPressGestureDetector::DownCast(arg1);
27664     } catch (std::out_of_range& e) {
27665       {
27666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27667       };
27668     } catch (std::exception& e) {
27669       {
27670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27671       };
27672     } catch (...) {
27673       {
27674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27675       };
27676     }
27677   }
27678   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27679   return jresult;
27680 }
27681
27682
27683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27684   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27685
27686   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27687   {
27688     try {
27689       delete arg1;
27690     } catch (std::out_of_range& e) {
27691       {
27692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27693       };
27694     } catch (std::exception& e) {
27695       {
27696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27697       };
27698     } catch (...) {
27699       {
27700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27701       };
27702     }
27703   }
27704 }
27705
27706
27707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27708   void * jresult ;
27709   Dali::LongPressGestureDetector *arg1 = 0 ;
27710   Dali::LongPressGestureDetector *result = 0 ;
27711
27712   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27713   if (!arg1) {
27714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27715     return 0;
27716   }
27717   {
27718     try {
27719       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27720     } catch (std::out_of_range& e) {
27721       {
27722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27723       };
27724     } catch (std::exception& e) {
27725       {
27726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27727       };
27728     } catch (...) {
27729       {
27730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27731       };
27732     }
27733   }
27734   jresult = (void *)result;
27735   return jresult;
27736 }
27737
27738
27739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27740   void * jresult ;
27741   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27742   Dali::LongPressGestureDetector *arg2 = 0 ;
27743   Dali::LongPressGestureDetector *result = 0 ;
27744
27745   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27746   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27747   if (!arg2) {
27748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27749     return 0;
27750   }
27751   {
27752     try {
27753       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27754     } catch (std::out_of_range& e) {
27755       {
27756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27757       };
27758     } catch (std::exception& e) {
27759       {
27760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27761       };
27762     } catch (...) {
27763       {
27764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27765       };
27766     }
27767   }
27768   jresult = (void *)result;
27769   return jresult;
27770 }
27771
27772
27773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27774   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27775   unsigned int arg2 ;
27776
27777   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27778   arg2 = (unsigned int)jarg2;
27779   {
27780     try {
27781       (arg1)->SetTouchesRequired(arg2);
27782     } catch (std::out_of_range& e) {
27783       {
27784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27785       };
27786     } catch (std::exception& e) {
27787       {
27788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27789       };
27790     } catch (...) {
27791       {
27792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27793       };
27794     }
27795   }
27796 }
27797
27798
27799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27800   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27801   unsigned int arg2 ;
27802   unsigned int arg3 ;
27803
27804   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27805   arg2 = (unsigned int)jarg2;
27806   arg3 = (unsigned int)jarg3;
27807   {
27808     try {
27809       (arg1)->SetTouchesRequired(arg2,arg3);
27810     } catch (std::out_of_range& e) {
27811       {
27812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27813       };
27814     } catch (std::exception& e) {
27815       {
27816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27817       };
27818     } catch (...) {
27819       {
27820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27821       };
27822     }
27823   }
27824 }
27825
27826
27827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27828   unsigned int jresult ;
27829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27830   unsigned int result;
27831
27832   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27833   {
27834     try {
27835       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27836     } catch (std::out_of_range& e) {
27837       {
27838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (std::exception& e) {
27841       {
27842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (...) {
27845       {
27846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27847       };
27848     }
27849   }
27850   jresult = result;
27851   return jresult;
27852 }
27853
27854
27855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27856   unsigned int jresult ;
27857   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27858   unsigned int result;
27859
27860   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27861   {
27862     try {
27863       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27864     } catch (std::out_of_range& e) {
27865       {
27866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27867       };
27868     } catch (std::exception& e) {
27869       {
27870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27871       };
27872     } catch (...) {
27873       {
27874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27875       };
27876     }
27877   }
27878   jresult = result;
27879   return jresult;
27880 }
27881
27882
27883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27884   void * jresult ;
27885   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27886   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27887
27888   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27889   {
27890     try {
27891       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27892     } catch (std::out_of_range& e) {
27893       {
27894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27895       };
27896     } catch (std::exception& e) {
27897       {
27898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27899       };
27900     } catch (...) {
27901       {
27902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27903       };
27904     }
27905   }
27906   jresult = (void *)result;
27907   return jresult;
27908 }
27909
27910
27911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27912   void * jresult ;
27913   Dali::Gesture::State arg1 ;
27914   Dali::LongPressGesture *result = 0 ;
27915
27916   arg1 = (Dali::Gesture::State)jarg1;
27917   {
27918     try {
27919       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27920     } catch (std::out_of_range& e) {
27921       {
27922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27923       };
27924     } catch (std::exception& e) {
27925       {
27926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (...) {
27929       {
27930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27931       };
27932     }
27933   }
27934   jresult = (void *)result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27940   void * jresult ;
27941   Dali::LongPressGesture *arg1 = 0 ;
27942   Dali::LongPressGesture *result = 0 ;
27943
27944   arg1 = (Dali::LongPressGesture *)jarg1;
27945   if (!arg1) {
27946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27947     return 0;
27948   }
27949   {
27950     try {
27951       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27952     } catch (std::out_of_range& e) {
27953       {
27954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27955       };
27956     } catch (std::exception& e) {
27957       {
27958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (...) {
27961       {
27962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27963       };
27964     }
27965   }
27966   jresult = (void *)result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27972   void * jresult ;
27973   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27974   Dali::LongPressGesture *arg2 = 0 ;
27975   Dali::LongPressGesture *result = 0 ;
27976
27977   arg1 = (Dali::LongPressGesture *)jarg1;
27978   arg2 = (Dali::LongPressGesture *)jarg2;
27979   if (!arg2) {
27980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27981     return 0;
27982   }
27983   {
27984     try {
27985       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27986     } catch (std::out_of_range& e) {
27987       {
27988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (std::exception& e) {
27991       {
27992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27993       };
27994     } catch (...) {
27995       {
27996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27997       };
27998     }
27999   }
28000   jresult = (void *)result;
28001   return jresult;
28002 }
28003
28004
28005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28006   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28007
28008   arg1 = (Dali::LongPressGesture *)jarg1;
28009   {
28010     try {
28011       delete arg1;
28012     } catch (std::out_of_range& e) {
28013       {
28014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28015       };
28016     } catch (std::exception& e) {
28017       {
28018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28019       };
28020     } catch (...) {
28021       {
28022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28023       };
28024     }
28025   }
28026 }
28027
28028
28029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28030   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28031   unsigned int arg2 ;
28032
28033   arg1 = (Dali::LongPressGesture *)jarg1;
28034   arg2 = (unsigned int)jarg2;
28035   if (arg1) (arg1)->numberOfTouches = arg2;
28036 }
28037
28038
28039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28040   unsigned int jresult ;
28041   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28042   unsigned int result;
28043
28044   arg1 = (Dali::LongPressGesture *)jarg1;
28045   result = (unsigned int) ((arg1)->numberOfTouches);
28046   jresult = result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28052   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28053   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28054
28055   arg1 = (Dali::LongPressGesture *)jarg1;
28056   arg2 = (Dali::Vector2 *)jarg2;
28057   if (arg1) (arg1)->screenPoint = *arg2;
28058 }
28059
28060
28061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28062   void * jresult ;
28063   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28064   Dali::Vector2 *result = 0 ;
28065
28066   arg1 = (Dali::LongPressGesture *)jarg1;
28067   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28068   jresult = (void *)result;
28069   return jresult;
28070 }
28071
28072
28073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28074   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28075   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28076
28077   arg1 = (Dali::LongPressGesture *)jarg1;
28078   arg2 = (Dali::Vector2 *)jarg2;
28079   if (arg1) (arg1)->localPoint = *arg2;
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28084   void * jresult ;
28085   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28086   Dali::Vector2 *result = 0 ;
28087
28088   arg1 = (Dali::LongPressGesture *)jarg1;
28089   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28090   jresult = (void *)result;
28091   return jresult;
28092 }
28093
28094
28095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28096   void * jresult ;
28097   Dali::WheelEvent *result = 0 ;
28098
28099   {
28100     try {
28101       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28102     } catch (std::out_of_range& e) {
28103       {
28104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28105       };
28106     } catch (std::exception& e) {
28107       {
28108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28109       };
28110     } catch (...) {
28111       {
28112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28113       };
28114     }
28115   }
28116   jresult = (void *)result;
28117   return jresult;
28118 }
28119
28120
28121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28122   void * jresult ;
28123   Dali::WheelEvent::Type arg1 ;
28124   int arg2 ;
28125   unsigned int arg3 ;
28126   Dali::Vector2 arg4 ;
28127   int arg5 ;
28128   unsigned int arg6 ;
28129   Dali::Vector2 *argp4 ;
28130   Dali::WheelEvent *result = 0 ;
28131
28132   arg1 = (Dali::WheelEvent::Type)jarg1;
28133   arg2 = (int)jarg2;
28134   arg3 = (unsigned int)jarg3;
28135   argp4 = (Dali::Vector2 *)jarg4;
28136   if (!argp4) {
28137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28138     return 0;
28139   }
28140   arg4 = *argp4;
28141   arg5 = (int)jarg5;
28142   arg6 = (unsigned int)jarg6;
28143   {
28144     try {
28145       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28146     } catch (std::out_of_range& e) {
28147       {
28148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28149       };
28150     } catch (std::exception& e) {
28151       {
28152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28153       };
28154     } catch (...) {
28155       {
28156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28157       };
28158     }
28159   }
28160   jresult = (void *)result;
28161   return jresult;
28162 }
28163
28164
28165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28166   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28167
28168   arg1 = (Dali::WheelEvent *)jarg1;
28169   {
28170     try {
28171       delete arg1;
28172     } catch (std::out_of_range& e) {
28173       {
28174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28175       };
28176     } catch (std::exception& e) {
28177       {
28178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28179       };
28180     } catch (...) {
28181       {
28182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28183       };
28184     }
28185   }
28186 }
28187
28188
28189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28190   unsigned int jresult ;
28191   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28192   bool result;
28193
28194   arg1 = (Dali::WheelEvent *)jarg1;
28195   {
28196     try {
28197       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28198     } catch (std::out_of_range& e) {
28199       {
28200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28201       };
28202     } catch (std::exception& e) {
28203       {
28204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28205       };
28206     } catch (...) {
28207       {
28208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28209       };
28210     }
28211   }
28212   jresult = result;
28213   return jresult;
28214 }
28215
28216
28217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28218   unsigned int jresult ;
28219   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28220   bool result;
28221
28222   arg1 = (Dali::WheelEvent *)jarg1;
28223   {
28224     try {
28225       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28226     } catch (std::out_of_range& e) {
28227       {
28228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28229       };
28230     } catch (std::exception& e) {
28231       {
28232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28233       };
28234     } catch (...) {
28235       {
28236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28237       };
28238     }
28239   }
28240   jresult = result;
28241   return jresult;
28242 }
28243
28244
28245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28246   unsigned int jresult ;
28247   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28248   bool result;
28249
28250   arg1 = (Dali::WheelEvent *)jarg1;
28251   {
28252     try {
28253       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28254     } catch (std::out_of_range& e) {
28255       {
28256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28257       };
28258     } catch (std::exception& e) {
28259       {
28260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28261       };
28262     } catch (...) {
28263       {
28264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28265       };
28266     }
28267   }
28268   jresult = result;
28269   return jresult;
28270 }
28271
28272
28273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28274   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28275   Dali::WheelEvent::Type arg2 ;
28276
28277   arg1 = (Dali::WheelEvent *)jarg1;
28278   arg2 = (Dali::WheelEvent::Type)jarg2;
28279   if (arg1) (arg1)->type = arg2;
28280 }
28281
28282
28283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28284   int jresult ;
28285   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28286   Dali::WheelEvent::Type result;
28287
28288   arg1 = (Dali::WheelEvent *)jarg1;
28289   result = (Dali::WheelEvent::Type) ((arg1)->type);
28290   jresult = (int)result;
28291   return jresult;
28292 }
28293
28294
28295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28296   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28297   int arg2 ;
28298
28299   arg1 = (Dali::WheelEvent *)jarg1;
28300   arg2 = (int)jarg2;
28301   if (arg1) (arg1)->direction = arg2;
28302 }
28303
28304
28305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28306   int jresult ;
28307   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28308   int result;
28309
28310   arg1 = (Dali::WheelEvent *)jarg1;
28311   result = (int) ((arg1)->direction);
28312   jresult = result;
28313   return jresult;
28314 }
28315
28316
28317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28318   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28319   unsigned int arg2 ;
28320
28321   arg1 = (Dali::WheelEvent *)jarg1;
28322   arg2 = (unsigned int)jarg2;
28323   if (arg1) (arg1)->modifiers = arg2;
28324 }
28325
28326
28327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28328   unsigned int jresult ;
28329   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28330   unsigned int result;
28331
28332   arg1 = (Dali::WheelEvent *)jarg1;
28333   result = (unsigned int) ((arg1)->modifiers);
28334   jresult = result;
28335   return jresult;
28336 }
28337
28338
28339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28340   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28341   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28342
28343   arg1 = (Dali::WheelEvent *)jarg1;
28344   arg2 = (Dali::Vector2 *)jarg2;
28345   if (arg1) (arg1)->point = *arg2;
28346 }
28347
28348
28349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28350   void * jresult ;
28351   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28352   Dali::Vector2 *result = 0 ;
28353
28354   arg1 = (Dali::WheelEvent *)jarg1;
28355   result = (Dali::Vector2 *)& ((arg1)->point);
28356   jresult = (void *)result;
28357   return jresult;
28358 }
28359
28360
28361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28362   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28363   int arg2 ;
28364
28365   arg1 = (Dali::WheelEvent *)jarg1;
28366   arg2 = (int)jarg2;
28367   if (arg1) (arg1)->z = arg2;
28368 }
28369
28370
28371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28372   int jresult ;
28373   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28374   int result;
28375
28376   arg1 = (Dali::WheelEvent *)jarg1;
28377   result = (int) ((arg1)->z);
28378   jresult = result;
28379   return jresult;
28380 }
28381
28382
28383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28384   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28385   unsigned int arg2 ;
28386
28387   arg1 = (Dali::WheelEvent *)jarg1;
28388   arg2 = (unsigned int)jarg2;
28389   if (arg1) (arg1)->timeStamp = arg2;
28390 }
28391
28392
28393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28394   unsigned int jresult ;
28395   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28396   unsigned int result;
28397
28398   arg1 = (Dali::WheelEvent *)jarg1;
28399   result = (unsigned int) ((arg1)->timeStamp);
28400   jresult = result;
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28406   int jresult ;
28407   int result;
28408
28409   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28410   jresult = (int)result;
28411   return jresult;
28412 }
28413
28414
28415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28416   int jresult ;
28417   int result;
28418
28419   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28420   jresult = (int)result;
28421   return jresult;
28422 }
28423
28424
28425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28426   int jresult ;
28427   int result;
28428
28429   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28430   jresult = (int)result;
28431   return jresult;
28432 }
28433
28434
28435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28436   int jresult ;
28437   int result;
28438
28439   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28440   jresult = (int)result;
28441   return jresult;
28442 }
28443
28444
28445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28446   int jresult ;
28447   int result;
28448
28449   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28450   jresult = (int)result;
28451   return jresult;
28452 }
28453
28454
28455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28456   int jresult ;
28457   int result;
28458
28459   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28460   jresult = (int)result;
28461   return jresult;
28462 }
28463
28464
28465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28466   int jresult ;
28467   int result;
28468
28469   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28470   jresult = (int)result;
28471   return jresult;
28472 }
28473
28474
28475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28476   int jresult ;
28477   int result;
28478
28479   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28480   jresult = (int)result;
28481   return jresult;
28482 }
28483
28484
28485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28486   int jresult ;
28487   int result;
28488
28489   result = (int)Dali::Actor::Property::SIZE;
28490   jresult = (int)result;
28491   return jresult;
28492 }
28493
28494
28495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28496   int jresult ;
28497   int result;
28498
28499   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28500   jresult = (int)result;
28501   return jresult;
28502 }
28503
28504
28505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28506   int jresult ;
28507   int result;
28508
28509   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28510   jresult = (int)result;
28511   return jresult;
28512 }
28513
28514
28515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28516   int jresult ;
28517   int result;
28518
28519   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28520   jresult = (int)result;
28521   return jresult;
28522 }
28523
28524
28525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28526   int jresult ;
28527   int result;
28528
28529   result = (int)Dali::Actor::Property::POSITION;
28530   jresult = (int)result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28536   int jresult ;
28537   int result;
28538
28539   result = (int)Dali::Actor::Property::POSITION_X;
28540   jresult = (int)result;
28541   return jresult;
28542 }
28543
28544
28545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28546   int jresult ;
28547   int result;
28548
28549   result = (int)Dali::Actor::Property::POSITION_Y;
28550   jresult = (int)result;
28551   return jresult;
28552 }
28553
28554
28555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28556   int jresult ;
28557   int result;
28558
28559   result = (int)Dali::Actor::Property::POSITION_Z;
28560   jresult = (int)result;
28561   return jresult;
28562 }
28563
28564
28565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28566   int jresult ;
28567   int result;
28568
28569   result = (int)Dali::Actor::Property::WORLD_POSITION;
28570   jresult = (int)result;
28571   return jresult;
28572 }
28573
28574
28575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28576   int jresult ;
28577   int result;
28578
28579   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28580   jresult = (int)result;
28581   return jresult;
28582 }
28583
28584
28585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28586   int jresult ;
28587   int result;
28588
28589   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28590   jresult = (int)result;
28591   return jresult;
28592 }
28593
28594
28595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28596   int jresult ;
28597   int result;
28598
28599   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28600   jresult = (int)result;
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28606   int jresult ;
28607   int result;
28608
28609   result = (int)Dali::Actor::Property::ORIENTATION;
28610   jresult = (int)result;
28611   return jresult;
28612 }
28613
28614
28615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28616   int jresult ;
28617   int result;
28618
28619   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28620   jresult = (int)result;
28621   return jresult;
28622 }
28623
28624
28625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28626   int jresult ;
28627   int result;
28628
28629   result = (int)Dali::Actor::Property::SCALE;
28630   jresult = (int)result;
28631   return jresult;
28632 }
28633
28634
28635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28636   int jresult ;
28637   int result;
28638
28639   result = (int)Dali::Actor::Property::SCALE_X;
28640   jresult = (int)result;
28641   return jresult;
28642 }
28643
28644
28645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28646   int jresult ;
28647   int result;
28648
28649   result = (int)Dali::Actor::Property::SCALE_Y;
28650   jresult = (int)result;
28651   return jresult;
28652 }
28653
28654
28655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28656   int jresult ;
28657   int result;
28658
28659   result = (int)Dali::Actor::Property::SCALE_Z;
28660   jresult = (int)result;
28661   return jresult;
28662 }
28663
28664
28665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28666   int jresult ;
28667   int result;
28668
28669   result = (int)Dali::Actor::Property::WORLD_SCALE;
28670   jresult = (int)result;
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28676   int jresult ;
28677   int result;
28678
28679   result = (int)Dali::Actor::Property::VISIBLE;
28680   jresult = (int)result;
28681   return jresult;
28682 }
28683
28684
28685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28686   int jresult ;
28687   int result;
28688
28689   result = (int)Dali::Actor::Property::COLOR;
28690   jresult = (int)result;
28691   return jresult;
28692 }
28693
28694
28695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28696   int jresult ;
28697   int result;
28698
28699   result = (int)Dali::Actor::Property::COLOR_RED;
28700   jresult = (int)result;
28701   return jresult;
28702 }
28703
28704
28705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28706   int jresult ;
28707   int result;
28708
28709   result = (int)Dali::Actor::Property::COLOR_GREEN;
28710   jresult = (int)result;
28711   return jresult;
28712 }
28713
28714
28715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28716   int jresult ;
28717   int result;
28718
28719   result = (int)Dali::Actor::Property::COLOR_BLUE;
28720   jresult = (int)result;
28721   return jresult;
28722 }
28723
28724
28725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28726   int jresult ;
28727   int result;
28728
28729   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28730   jresult = (int)result;
28731   return jresult;
28732 }
28733
28734
28735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28736   int jresult ;
28737   int result;
28738
28739   result = (int)Dali::Actor::Property::WORLD_COLOR;
28740   jresult = (int)result;
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28746   int jresult ;
28747   int result;
28748
28749   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28750   jresult = (int)result;
28751   return jresult;
28752 }
28753
28754
28755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28756   int jresult ;
28757   int result;
28758
28759   result = (int)Dali::Actor::Property::NAME;
28760   jresult = (int)result;
28761   return jresult;
28762 }
28763
28764
28765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28766   int jresult ;
28767   int result;
28768
28769   result = (int)Dali::Actor::Property::SENSITIVE;
28770   jresult = (int)result;
28771   return jresult;
28772 }
28773
28774
28775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28776   int jresult ;
28777   int result;
28778
28779   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28780   jresult = (int)result;
28781   return jresult;
28782 }
28783
28784
28785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28786   int jresult ;
28787   int result;
28788
28789   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28790   jresult = (int)result;
28791   return jresult;
28792 }
28793
28794
28795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28796   int jresult ;
28797   int result;
28798
28799   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28800   jresult = (int)result;
28801   return jresult;
28802 }
28803
28804
28805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28806   int jresult ;
28807   int result;
28808
28809   result = (int)Dali::Actor::Property::COLOR_MODE;
28810   jresult = (int)result;
28811   return jresult;
28812 }
28813
28814
28815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28816   int jresult ;
28817   int result;
28818
28819   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28820   jresult = (int)result;
28821   return jresult;
28822 }
28823
28824
28825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28826   int jresult ;
28827   int result;
28828
28829   result = (int)Dali::Actor::Property::DRAW_MODE;
28830   jresult = (int)result;
28831   return jresult;
28832 }
28833
28834
28835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28836   int jresult ;
28837   int result;
28838
28839   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28840   jresult = (int)result;
28841   return jresult;
28842 }
28843
28844
28845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28846   int jresult ;
28847   int result;
28848
28849   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28850   jresult = (int)result;
28851   return jresult;
28852 }
28853
28854
28855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28856   int jresult ;
28857   int result;
28858
28859   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28860   jresult = (int)result;
28861   return jresult;
28862 }
28863
28864
28865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28866   int jresult ;
28867   int result;
28868
28869   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28870   jresult = (int)result;
28871   return jresult;
28872 }
28873
28874
28875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28876   int jresult ;
28877   int result;
28878
28879   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28880   jresult = (int)result;
28881   return jresult;
28882 }
28883
28884
28885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28886   int jresult ;
28887   int result;
28888
28889   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28890   jresult = (int)result;
28891   return jresult;
28892 }
28893
28894
28895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28896   int jresult ;
28897   int result;
28898
28899   result = (int)Dali::Actor::Property::PADDING;
28900   jresult = (int)result;
28901   return jresult;
28902 }
28903
28904
28905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28906   int jresult ;
28907   int result;
28908
28909   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28910   jresult = (int)result;
28911   return jresult;
28912 }
28913
28914
28915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28916   int jresult ;
28917   int result;
28918
28919   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28920   jresult = (int)result;
28921   return jresult;
28922 }
28923
28924
28925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28926   int jresult ;
28927   int result;
28928
28929   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28930   jresult = (int)result;
28931   return jresult;
28932 }
28933
28934
28935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28936   int jresult ;
28937   int result;
28938
28939   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28940   jresult = (int)result;
28941   return jresult;
28942 }
28943
28944
28945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28946   void * jresult ;
28947   Dali::Actor::Property *result = 0 ;
28948
28949   {
28950     try {
28951       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28952     } catch (std::out_of_range& e) {
28953       {
28954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28955       };
28956     } catch (std::exception& e) {
28957       {
28958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28959       };
28960     } catch (...) {
28961       {
28962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28963       };
28964     }
28965   }
28966   jresult = (void *)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28972   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28973
28974   arg1 = (Dali::Actor::Property *)jarg1;
28975   {
28976     try {
28977       delete arg1;
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28985       };
28986     } catch (...) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28989       };
28990     }
28991   }
28992 }
28993
28994
28995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28996   void * jresult ;
28997   Dali::Actor *result = 0 ;
28998
28999   {
29000     try {
29001       result = (Dali::Actor *)new Dali::Actor();
29002     } catch (std::out_of_range& e) {
29003       {
29004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29005       };
29006     } catch (std::exception& e) {
29007       {
29008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29009       };
29010     } catch (...) {
29011       {
29012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29013       };
29014     }
29015   }
29016   jresult = (void *)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29022   void * jresult ;
29023   Dali::Actor result;
29024
29025   {
29026     try {
29027       result = Dali::Actor::New();
29028     } catch (std::out_of_range& e) {
29029       {
29030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29031       };
29032     } catch (std::exception& e) {
29033       {
29034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29035       };
29036     } catch (...) {
29037       {
29038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29039       };
29040     }
29041   }
29042   jresult = new Dali::Actor((const Dali::Actor &)result);
29043   return jresult;
29044 }
29045
29046
29047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29048   void * jresult ;
29049   Dali::BaseHandle arg1 ;
29050   Dali::BaseHandle *argp1 ;
29051   Dali::Actor result;
29052
29053   argp1 = (Dali::BaseHandle *)jarg1;
29054   if (!argp1) {
29055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29056     return 0;
29057   }
29058   arg1 = *argp1;
29059   {
29060     try {
29061       result = Dali::Actor::DownCast(arg1);
29062     } catch (std::out_of_range& e) {
29063       {
29064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29065       };
29066     } catch (std::exception& e) {
29067       {
29068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29069       };
29070     } catch (...) {
29071       {
29072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29073       };
29074     }
29075   }
29076   jresult = new Dali::Actor((const Dali::Actor &)result);
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29083
29084   arg1 = (Dali::Actor *)jarg1;
29085   {
29086     try {
29087       delete arg1;
29088     } catch (std::out_of_range& e) {
29089       {
29090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29091       };
29092     } catch (std::exception& e) {
29093       {
29094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29095       };
29096     } catch (...) {
29097       {
29098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29099       };
29100     }
29101   }
29102 }
29103
29104
29105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29106   void * jresult ;
29107   Dali::Actor *arg1 = 0 ;
29108   Dali::Actor *result = 0 ;
29109
29110   arg1 = (Dali::Actor *)jarg1;
29111   if (!arg1) {
29112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29113     return 0;
29114   }
29115   {
29116     try {
29117       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (...) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29129       };
29130     }
29131   }
29132   jresult = (void *)result;
29133   return jresult;
29134 }
29135
29136
29137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29138   void * jresult ;
29139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29140   Dali::Actor *arg2 = 0 ;
29141   Dali::Actor *result = 0 ;
29142
29143   arg1 = (Dali::Actor *)jarg1;
29144   arg2 = (Dali::Actor *)jarg2;
29145   if (!arg2) {
29146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29147     return 0;
29148   }
29149   {
29150     try {
29151       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29152     } catch (std::out_of_range& e) {
29153       {
29154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29155       };
29156     } catch (std::exception& e) {
29157       {
29158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29159       };
29160     } catch (...) {
29161       {
29162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29163       };
29164     }
29165   }
29166   jresult = (void *)result;
29167   return jresult;
29168 }
29169
29170
29171 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29172   char * jresult ;
29173   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29174   std::string *result = 0 ;
29175
29176   arg1 = (Dali::Actor *)jarg1;
29177   {
29178     try {
29179       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29180     } catch (std::out_of_range& e) {
29181       {
29182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29183       };
29184     } catch (std::exception& e) {
29185       {
29186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29187       };
29188     } catch (...) {
29189       {
29190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29191       };
29192     }
29193   }
29194   jresult = SWIG_csharp_string_callback(result->c_str());
29195   return jresult;
29196 }
29197
29198
29199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29201   std::string *arg2 = 0 ;
29202
29203   arg1 = (Dali::Actor *)jarg1;
29204   if (!jarg2) {
29205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29206     return ;
29207   }
29208   std::string arg2_str(jarg2);
29209   arg2 = &arg2_str;
29210   {
29211     try {
29212       (arg1)->SetName((std::string const &)*arg2);
29213     } catch (std::out_of_range& e) {
29214       {
29215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29216       };
29217     } catch (std::exception& e) {
29218       {
29219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29220       };
29221     } catch (...) {
29222       {
29223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29224       };
29225     }
29226   }
29227
29228   //argout typemap for const std::string&
29229
29230 }
29231
29232
29233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29234   unsigned int jresult ;
29235   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29236   unsigned int result;
29237
29238   arg1 = (Dali::Actor *)jarg1;
29239   {
29240     try {
29241       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29242     } catch (std::out_of_range& e) {
29243       {
29244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29245       };
29246     } catch (std::exception& e) {
29247       {
29248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29249       };
29250     } catch (...) {
29251       {
29252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29253       };
29254     }
29255   }
29256   jresult = result;
29257   return jresult;
29258 }
29259
29260
29261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29262   unsigned int jresult ;
29263   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29264   bool result;
29265
29266   arg1 = (Dali::Actor *)jarg1;
29267   {
29268     try {
29269       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29270     } catch (std::out_of_range& e) {
29271       {
29272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29273       };
29274     } catch (std::exception& e) {
29275       {
29276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29277       };
29278     } catch (...) {
29279       {
29280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29281       };
29282     }
29283   }
29284   jresult = result;
29285   return jresult;
29286 }
29287
29288
29289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29290   unsigned int jresult ;
29291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29292   bool result;
29293
29294   arg1 = (Dali::Actor *)jarg1;
29295   {
29296     try {
29297       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29298     } catch (std::out_of_range& e) {
29299       {
29300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29301       };
29302     } catch (std::exception& e) {
29303       {
29304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29309       };
29310     }
29311   }
29312   jresult = result;
29313   return jresult;
29314 }
29315
29316
29317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29318   unsigned int jresult ;
29319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29320   bool result;
29321
29322   arg1 = (Dali::Actor *)jarg1;
29323   {
29324     try {
29325       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29326     } catch (std::out_of_range& e) {
29327       {
29328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (std::exception& e) {
29331       {
29332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29333       };
29334     } catch (...) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29337       };
29338     }
29339   }
29340   jresult = result;
29341   return jresult;
29342 }
29343
29344
29345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29346   void * jresult ;
29347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29348   Dali::Layer result;
29349
29350   arg1 = (Dali::Actor *)jarg1;
29351   {
29352     try {
29353       result = (arg1)->GetLayer();
29354     } catch (std::out_of_range& e) {
29355       {
29356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29357       };
29358     } catch (std::exception& e) {
29359       {
29360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29361       };
29362     } catch (...) {
29363       {
29364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29365       };
29366     }
29367   }
29368   jresult = new Dali::Layer((const Dali::Layer &)result);
29369   return jresult;
29370 }
29371
29372
29373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29374   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29375   Dali::Actor arg2 ;
29376   Dali::Actor *argp2 ;
29377
29378   arg1 = (Dali::Actor *)jarg1;
29379   argp2 = (Dali::Actor *)jarg2;
29380   if (!argp2) {
29381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29382     return ;
29383   }
29384   arg2 = *argp2;
29385   {
29386     try {
29387       (arg1)->Add(arg2);
29388     } catch (std::out_of_range& e) {
29389       {
29390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29391       };
29392     } catch (std::exception& e) {
29393       {
29394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29395       };
29396     } catch (...) {
29397       {
29398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29399       };
29400     }
29401   }
29402 }
29403
29404
29405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29407   Dali::Actor arg2 ;
29408   Dali::Actor *argp2 ;
29409
29410   arg1 = (Dali::Actor *)jarg1;
29411   argp2 = (Dali::Actor *)jarg2;
29412   if (!argp2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29414     return ;
29415   }
29416   arg2 = *argp2;
29417   {
29418     try {
29419       (arg1)->Remove(arg2);
29420     } catch (std::out_of_range& e) {
29421       {
29422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29423       };
29424     } catch (std::exception& e) {
29425       {
29426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29431       };
29432     }
29433   }
29434 }
29435
29436
29437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29439
29440   arg1 = (Dali::Actor *)jarg1;
29441   {
29442     try {
29443       (arg1)->Unparent();
29444     } catch (std::out_of_range& e) {
29445       {
29446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29447       };
29448     } catch (std::exception& e) {
29449       {
29450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29451       };
29452     } catch (...) {
29453       {
29454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29455       };
29456     }
29457   }
29458 }
29459
29460
29461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29462   unsigned int jresult ;
29463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29464   unsigned int result;
29465
29466   arg1 = (Dali::Actor *)jarg1;
29467   {
29468     try {
29469       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29470     } catch (std::out_of_range& e) {
29471       {
29472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (std::exception& e) {
29475       {
29476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29477       };
29478     } catch (...) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29481       };
29482     }
29483   }
29484   jresult = result;
29485   return jresult;
29486 }
29487
29488
29489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29490   void * jresult ;
29491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29492   unsigned int arg2 ;
29493   Dali::Actor result;
29494
29495   arg1 = (Dali::Actor *)jarg1;
29496   arg2 = (unsigned int)jarg2;
29497   {
29498     try {
29499       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29500     } catch (std::out_of_range& e) {
29501       {
29502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29503       };
29504     } catch (std::exception& e) {
29505       {
29506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29507       };
29508     } catch (...) {
29509       {
29510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29511       };
29512     }
29513   }
29514   jresult = new Dali::Actor((const Dali::Actor &)result);
29515   return jresult;
29516 }
29517
29518
29519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29520   void * jresult ;
29521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29522   std::string *arg2 = 0 ;
29523   Dali::Actor result;
29524
29525   arg1 = (Dali::Actor *)jarg1;
29526   if (!jarg2) {
29527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29528     return 0;
29529   }
29530   std::string arg2_str(jarg2);
29531   arg2 = &arg2_str;
29532   {
29533     try {
29534       result = (arg1)->FindChildByName((std::string const &)*arg2);
29535     } catch (std::out_of_range& e) {
29536       {
29537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (std::exception& e) {
29540       {
29541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29542       };
29543     } catch (...) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29546       };
29547     }
29548   }
29549   jresult = new Dali::Actor((const Dali::Actor &)result);
29550
29551   //argout typemap for const std::string&
29552
29553   return jresult;
29554 }
29555
29556
29557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29558   void * jresult ;
29559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29560   unsigned int arg2 ;
29561   Dali::Actor result;
29562
29563   arg1 = (Dali::Actor *)jarg1;
29564   arg2 = (unsigned int)jarg2;
29565   {
29566     try {
29567       result = (arg1)->FindChildById(arg2);
29568     } catch (std::out_of_range& e) {
29569       {
29570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29571       };
29572     } catch (std::exception& e) {
29573       {
29574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29575       };
29576     } catch (...) {
29577       {
29578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29579       };
29580     }
29581   }
29582   jresult = new Dali::Actor((const Dali::Actor &)result);
29583   return jresult;
29584 }
29585
29586
29587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29588   void * jresult ;
29589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29590   Dali::Actor result;
29591
29592   arg1 = (Dali::Actor *)jarg1;
29593   {
29594     try {
29595       result = ((Dali::Actor const *)arg1)->GetParent();
29596     } catch (std::out_of_range& e) {
29597       {
29598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29599       };
29600     } catch (std::exception& e) {
29601       {
29602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29603       };
29604     } catch (...) {
29605       {
29606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29607       };
29608     }
29609   }
29610   jresult = new Dali::Actor((const Dali::Actor &)result);
29611   return jresult;
29612 }
29613
29614
29615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29617   Dali::Vector3 *arg2 = 0 ;
29618
29619   arg1 = (Dali::Actor *)jarg1;
29620   arg2 = (Dali::Vector3 *)jarg2;
29621   if (!arg2) {
29622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29623     return ;
29624   }
29625   {
29626     try {
29627       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29628     } catch (std::out_of_range& e) {
29629       {
29630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29631       };
29632     } catch (std::exception& e) {
29633       {
29634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29635       };
29636     } catch (...) {
29637       {
29638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29639       };
29640     }
29641   }
29642 }
29643
29644
29645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29646   void * jresult ;
29647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29648   Dali::Vector3 result;
29649
29650   arg1 = (Dali::Actor *)jarg1;
29651   {
29652     try {
29653       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29654     } catch (std::out_of_range& e) {
29655       {
29656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29657       };
29658     } catch (std::exception& e) {
29659       {
29660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29661       };
29662     } catch (...) {
29663       {
29664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29665       };
29666     }
29667   }
29668   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29675   Dali::Vector3 *arg2 = 0 ;
29676
29677   arg1 = (Dali::Actor *)jarg1;
29678   arg2 = (Dali::Vector3 *)jarg2;
29679   if (!arg2) {
29680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29681     return ;
29682   }
29683   {
29684     try {
29685       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29686     } catch (std::out_of_range& e) {
29687       {
29688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29689       };
29690     } catch (std::exception& e) {
29691       {
29692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29693       };
29694     } catch (...) {
29695       {
29696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29697       };
29698     }
29699   }
29700 }
29701
29702
29703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29704   void * jresult ;
29705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29706   Dali::Vector3 result;
29707
29708   arg1 = (Dali::Actor *)jarg1;
29709   {
29710     try {
29711       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29712     } catch (std::out_of_range& e) {
29713       {
29714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29715       };
29716     } catch (std::exception& e) {
29717       {
29718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29719       };
29720     } catch (...) {
29721       {
29722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29723       };
29724     }
29725   }
29726   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29727   return jresult;
29728 }
29729
29730
29731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29733   float arg2 ;
29734   float arg3 ;
29735
29736   arg1 = (Dali::Actor *)jarg1;
29737   arg2 = (float)jarg2;
29738   arg3 = (float)jarg3;
29739   {
29740     try {
29741       (arg1)->SetSize(arg2,arg3);
29742     } catch (std::out_of_range& e) {
29743       {
29744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29745       };
29746     } catch (std::exception& e) {
29747       {
29748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29753       };
29754     }
29755   }
29756 }
29757
29758
29759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29761   float arg2 ;
29762   float arg3 ;
29763   float arg4 ;
29764
29765   arg1 = (Dali::Actor *)jarg1;
29766   arg2 = (float)jarg2;
29767   arg3 = (float)jarg3;
29768   arg4 = (float)jarg4;
29769   {
29770     try {
29771       (arg1)->SetSize(arg2,arg3,arg4);
29772     } catch (std::out_of_range& e) {
29773       {
29774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29775       };
29776     } catch (std::exception& e) {
29777       {
29778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29779       };
29780     } catch (...) {
29781       {
29782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29783       };
29784     }
29785   }
29786 }
29787
29788
29789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29790   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29791   Dali::Vector2 *arg2 = 0 ;
29792
29793   arg1 = (Dali::Actor *)jarg1;
29794   arg2 = (Dali::Vector2 *)jarg2;
29795   if (!arg2) {
29796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29797     return ;
29798   }
29799   {
29800     try {
29801       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29802     } catch (std::out_of_range& e) {
29803       {
29804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29805       };
29806     } catch (std::exception& e) {
29807       {
29808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29809       };
29810     } catch (...) {
29811       {
29812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29813       };
29814     }
29815   }
29816 }
29817
29818
29819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29821   Dali::Vector3 *arg2 = 0 ;
29822
29823   arg1 = (Dali::Actor *)jarg1;
29824   arg2 = (Dali::Vector3 *)jarg2;
29825   if (!arg2) {
29826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29827     return ;
29828   }
29829   {
29830     try {
29831       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29832     } catch (std::out_of_range& e) {
29833       {
29834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29835       };
29836     } catch (std::exception& e) {
29837       {
29838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29839       };
29840     } catch (...) {
29841       {
29842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29843       };
29844     }
29845   }
29846 }
29847
29848
29849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29850   void * jresult ;
29851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29852   Dali::Vector3 result;
29853
29854   arg1 = (Dali::Actor *)jarg1;
29855   {
29856     try {
29857       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29858     } catch (std::out_of_range& e) {
29859       {
29860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29861       };
29862     } catch (std::exception& e) {
29863       {
29864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29865       };
29866     } catch (...) {
29867       {
29868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29869       };
29870     }
29871   }
29872   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29873   return jresult;
29874 }
29875
29876
29877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29878   void * jresult ;
29879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29880   Dali::Vector3 result;
29881
29882   arg1 = (Dali::Actor *)jarg1;
29883   {
29884     try {
29885       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29886     } catch (std::out_of_range& e) {
29887       {
29888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29889       };
29890     } catch (std::exception& e) {
29891       {
29892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29893       };
29894     } catch (...) {
29895       {
29896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29897       };
29898     }
29899   }
29900   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29906   void * jresult ;
29907   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29908   Dali::Vector3 result;
29909
29910   arg1 = (Dali::Actor *)jarg1;
29911   {
29912     try {
29913       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (...) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29925       };
29926     }
29927   }
29928   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29929   return jresult;
29930 }
29931
29932
29933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29935   float arg2 ;
29936   float arg3 ;
29937
29938   arg1 = (Dali::Actor *)jarg1;
29939   arg2 = (float)jarg2;
29940   arg3 = (float)jarg3;
29941   {
29942     try {
29943       (arg1)->SetPosition(arg2,arg3);
29944     } catch (std::out_of_range& e) {
29945       {
29946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29947       };
29948     } catch (std::exception& e) {
29949       {
29950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29951       };
29952     } catch (...) {
29953       {
29954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29955       };
29956     }
29957   }
29958 }
29959
29960
29961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29963   float arg2 ;
29964   float arg3 ;
29965   float arg4 ;
29966
29967   arg1 = (Dali::Actor *)jarg1;
29968   arg2 = (float)jarg2;
29969   arg3 = (float)jarg3;
29970   arg4 = (float)jarg4;
29971   {
29972     try {
29973       (arg1)->SetPosition(arg2,arg3,arg4);
29974     } catch (std::out_of_range& e) {
29975       {
29976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29977       };
29978     } catch (std::exception& e) {
29979       {
29980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29981       };
29982     } catch (...) {
29983       {
29984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29985       };
29986     }
29987   }
29988 }
29989
29990
29991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29993   Dali::Vector3 *arg2 = 0 ;
29994
29995   arg1 = (Dali::Actor *)jarg1;
29996   arg2 = (Dali::Vector3 *)jarg2;
29997   if (!arg2) {
29998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29999     return ;
30000   }
30001   {
30002     try {
30003       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30004     } catch (std::out_of_range& e) {
30005       {
30006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30007       };
30008     } catch (std::exception& e) {
30009       {
30010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30011       };
30012     } catch (...) {
30013       {
30014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30015       };
30016     }
30017   }
30018 }
30019
30020
30021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30023   float arg2 ;
30024
30025   arg1 = (Dali::Actor *)jarg1;
30026   arg2 = (float)jarg2;
30027   {
30028     try {
30029       (arg1)->SetX(arg2);
30030     } catch (std::out_of_range& e) {
30031       {
30032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30033       };
30034     } catch (std::exception& e) {
30035       {
30036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30037       };
30038     } catch (...) {
30039       {
30040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30041       };
30042     }
30043   }
30044 }
30045
30046
30047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30049   float arg2 ;
30050
30051   arg1 = (Dali::Actor *)jarg1;
30052   arg2 = (float)jarg2;
30053   {
30054     try {
30055       (arg1)->SetY(arg2);
30056     } catch (std::out_of_range& e) {
30057       {
30058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30059       };
30060     } catch (std::exception& e) {
30061       {
30062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30063       };
30064     } catch (...) {
30065       {
30066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30067       };
30068     }
30069   }
30070 }
30071
30072
30073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30074   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30075   float arg2 ;
30076
30077   arg1 = (Dali::Actor *)jarg1;
30078   arg2 = (float)jarg2;
30079   {
30080     try {
30081       (arg1)->SetZ(arg2);
30082     } catch (std::out_of_range& e) {
30083       {
30084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30085       };
30086     } catch (std::exception& e) {
30087       {
30088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30089       };
30090     } catch (...) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30093       };
30094     }
30095   }
30096 }
30097
30098
30099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30101   Dali::Vector3 *arg2 = 0 ;
30102
30103   arg1 = (Dali::Actor *)jarg1;
30104   arg2 = (Dali::Vector3 *)jarg2;
30105   if (!arg2) {
30106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30107     return ;
30108   }
30109   {
30110     try {
30111       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30112     } catch (std::out_of_range& e) {
30113       {
30114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30115       };
30116     } catch (std::exception& e) {
30117       {
30118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30119       };
30120     } catch (...) {
30121       {
30122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30123       };
30124     }
30125   }
30126 }
30127
30128
30129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30130   void * jresult ;
30131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30132   Dali::Vector3 result;
30133
30134   arg1 = (Dali::Actor *)jarg1;
30135   {
30136     try {
30137       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30138     } catch (std::out_of_range& e) {
30139       {
30140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30141       };
30142     } catch (std::exception& e) {
30143       {
30144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30145       };
30146     } catch (...) {
30147       {
30148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30149       };
30150     }
30151   }
30152   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30153   return jresult;
30154 }
30155
30156
30157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30158   void * jresult ;
30159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30160   Dali::Vector3 result;
30161
30162   arg1 = (Dali::Actor *)jarg1;
30163   {
30164     try {
30165       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30166     } catch (std::out_of_range& e) {
30167       {
30168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30169       };
30170     } catch (std::exception& e) {
30171       {
30172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30173       };
30174     } catch (...) {
30175       {
30176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30177       };
30178     }
30179   }
30180   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30181   return jresult;
30182 }
30183
30184
30185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30187   bool arg2 ;
30188
30189   arg1 = (Dali::Actor *)jarg1;
30190   arg2 = jarg2 ? true : false;
30191   {
30192     try {
30193       (arg1)->SetInheritPosition(arg2);
30194     } catch (std::out_of_range& e) {
30195       {
30196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30197       };
30198     } catch (std::exception& e) {
30199       {
30200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30201       };
30202     } catch (...) {
30203       {
30204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30205       };
30206     }
30207   }
30208 }
30209
30210
30211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30212   int jresult ;
30213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30214   Dali::PositionInheritanceMode result;
30215
30216   arg1 = (Dali::Actor *)jarg1;
30217   {
30218     try {
30219       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30220     } catch (std::out_of_range& e) {
30221       {
30222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30223       };
30224     } catch (std::exception& e) {
30225       {
30226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30227       };
30228     } catch (...) {
30229       {
30230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30231       };
30232     }
30233   }
30234   jresult = (int)result;
30235   return jresult;
30236 }
30237
30238
30239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30240   unsigned int jresult ;
30241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30242   bool result;
30243
30244   arg1 = (Dali::Actor *)jarg1;
30245   {
30246     try {
30247       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30248     } catch (std::out_of_range& e) {
30249       {
30250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30251       };
30252     } catch (std::exception& e) {
30253       {
30254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30255       };
30256     } catch (...) {
30257       {
30258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30259       };
30260     }
30261   }
30262   jresult = result;
30263   return jresult;
30264 }
30265
30266
30267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30269   Dali::Degree *arg2 = 0 ;
30270   Dali::Vector3 *arg3 = 0 ;
30271
30272   arg1 = (Dali::Actor *)jarg1;
30273   arg2 = (Dali::Degree *)jarg2;
30274   if (!arg2) {
30275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30276     return ;
30277   }
30278   arg3 = (Dali::Vector3 *)jarg3;
30279   if (!arg3) {
30280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30281     return ;
30282   }
30283   {
30284     try {
30285       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30286     } catch (std::out_of_range& e) {
30287       {
30288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30289       };
30290     } catch (std::exception& e) {
30291       {
30292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30293       };
30294     } catch (...) {
30295       {
30296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30297       };
30298     }
30299   }
30300 }
30301
30302
30303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30304   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30305   Dali::Radian *arg2 = 0 ;
30306   Dali::Vector3 *arg3 = 0 ;
30307
30308   arg1 = (Dali::Actor *)jarg1;
30309   arg2 = (Dali::Radian *)jarg2;
30310   if (!arg2) {
30311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30312     return ;
30313   }
30314   arg3 = (Dali::Vector3 *)jarg3;
30315   if (!arg3) {
30316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30317     return ;
30318   }
30319   {
30320     try {
30321       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30322     } catch (std::out_of_range& e) {
30323       {
30324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30325       };
30326     } catch (std::exception& e) {
30327       {
30328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (...) {
30331       {
30332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30333       };
30334     }
30335   }
30336 }
30337
30338
30339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30341   Dali::Quaternion *arg2 = 0 ;
30342
30343   arg1 = (Dali::Actor *)jarg1;
30344   arg2 = (Dali::Quaternion *)jarg2;
30345   if (!arg2) {
30346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30347     return ;
30348   }
30349   {
30350     try {
30351       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30352     } catch (std::out_of_range& e) {
30353       {
30354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (std::exception& e) {
30357       {
30358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30371   Dali::Degree *arg2 = 0 ;
30372   Dali::Vector3 *arg3 = 0 ;
30373
30374   arg1 = (Dali::Actor *)jarg1;
30375   arg2 = (Dali::Degree *)jarg2;
30376   if (!arg2) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30378     return ;
30379   }
30380   arg3 = (Dali::Vector3 *)jarg3;
30381   if (!arg3) {
30382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30383     return ;
30384   }
30385   {
30386     try {
30387       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30388     } catch (std::out_of_range& e) {
30389       {
30390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30391       };
30392     } catch (std::exception& e) {
30393       {
30394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30395       };
30396     } catch (...) {
30397       {
30398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30399       };
30400     }
30401   }
30402 }
30403
30404
30405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30407   Dali::Radian *arg2 = 0 ;
30408   Dali::Vector3 *arg3 = 0 ;
30409
30410   arg1 = (Dali::Actor *)jarg1;
30411   arg2 = (Dali::Radian *)jarg2;
30412   if (!arg2) {
30413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30414     return ;
30415   }
30416   arg3 = (Dali::Vector3 *)jarg3;
30417   if (!arg3) {
30418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30419     return ;
30420   }
30421   {
30422     try {
30423       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30424     } catch (std::out_of_range& e) {
30425       {
30426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30427       };
30428     } catch (std::exception& e) {
30429       {
30430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30431       };
30432     } catch (...) {
30433       {
30434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30435       };
30436     }
30437   }
30438 }
30439
30440
30441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30442   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30443   Dali::Quaternion *arg2 = 0 ;
30444
30445   arg1 = (Dali::Actor *)jarg1;
30446   arg2 = (Dali::Quaternion *)jarg2;
30447   if (!arg2) {
30448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30449     return ;
30450   }
30451   {
30452     try {
30453       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30454     } catch (std::out_of_range& e) {
30455       {
30456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30457       };
30458     } catch (std::exception& e) {
30459       {
30460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30461       };
30462     } catch (...) {
30463       {
30464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30465       };
30466     }
30467   }
30468 }
30469
30470
30471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30472   void * jresult ;
30473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30474   Dali::Quaternion result;
30475
30476   arg1 = (Dali::Actor *)jarg1;
30477   {
30478     try {
30479       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30480     } catch (std::out_of_range& e) {
30481       {
30482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30483       };
30484     } catch (std::exception& e) {
30485       {
30486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30487       };
30488     } catch (...) {
30489       {
30490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30491       };
30492     }
30493   }
30494   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30495   return jresult;
30496 }
30497
30498
30499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30501   bool arg2 ;
30502
30503   arg1 = (Dali::Actor *)jarg1;
30504   arg2 = jarg2 ? true : false;
30505   {
30506     try {
30507       (arg1)->SetInheritOrientation(arg2);
30508     } catch (std::out_of_range& e) {
30509       {
30510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30511       };
30512     } catch (std::exception& e) {
30513       {
30514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30515       };
30516     } catch (...) {
30517       {
30518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30519       };
30520     }
30521   }
30522 }
30523
30524
30525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30526   unsigned int jresult ;
30527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30528   bool result;
30529
30530   arg1 = (Dali::Actor *)jarg1;
30531   {
30532     try {
30533       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (...) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30545       };
30546     }
30547   }
30548   jresult = result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30554   void * jresult ;
30555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30556   Dali::Quaternion result;
30557
30558   arg1 = (Dali::Actor *)jarg1;
30559   {
30560     try {
30561       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30562     } catch (std::out_of_range& e) {
30563       {
30564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30565       };
30566     } catch (std::exception& e) {
30567       {
30568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30569       };
30570     } catch (...) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30573       };
30574     }
30575   }
30576   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30577   return jresult;
30578 }
30579
30580
30581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30583   float arg2 ;
30584
30585   arg1 = (Dali::Actor *)jarg1;
30586   arg2 = (float)jarg2;
30587   {
30588     try {
30589       (arg1)->SetScale(arg2);
30590     } catch (std::out_of_range& e) {
30591       {
30592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30593       };
30594     } catch (std::exception& e) {
30595       {
30596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30597       };
30598     } catch (...) {
30599       {
30600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30601       };
30602     }
30603   }
30604 }
30605
30606
30607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30609   float arg2 ;
30610   float arg3 ;
30611   float arg4 ;
30612
30613   arg1 = (Dali::Actor *)jarg1;
30614   arg2 = (float)jarg2;
30615   arg3 = (float)jarg3;
30616   arg4 = (float)jarg4;
30617   {
30618     try {
30619       (arg1)->SetScale(arg2,arg3,arg4);
30620     } catch (std::out_of_range& e) {
30621       {
30622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30623       };
30624     } catch (std::exception& e) {
30625       {
30626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30627       };
30628     } catch (...) {
30629       {
30630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30631       };
30632     }
30633   }
30634 }
30635
30636
30637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30639   Dali::Vector3 *arg2 = 0 ;
30640
30641   arg1 = (Dali::Actor *)jarg1;
30642   arg2 = (Dali::Vector3 *)jarg2;
30643   if (!arg2) {
30644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30645     return ;
30646   }
30647   {
30648     try {
30649       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30650     } catch (std::out_of_range& e) {
30651       {
30652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30653       };
30654     } catch (std::exception& e) {
30655       {
30656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30657       };
30658     } catch (...) {
30659       {
30660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30661       };
30662     }
30663   }
30664 }
30665
30666
30667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30669   Dali::Vector3 *arg2 = 0 ;
30670
30671   arg1 = (Dali::Actor *)jarg1;
30672   arg2 = (Dali::Vector3 *)jarg2;
30673   if (!arg2) {
30674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30675     return ;
30676   }
30677   {
30678     try {
30679       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30680     } catch (std::out_of_range& e) {
30681       {
30682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30683       };
30684     } catch (std::exception& e) {
30685       {
30686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30687       };
30688     } catch (...) {
30689       {
30690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30691       };
30692     }
30693   }
30694 }
30695
30696
30697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30698   void * jresult ;
30699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30700   Dali::Vector3 result;
30701
30702   arg1 = (Dali::Actor *)jarg1;
30703   {
30704     try {
30705       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30706     } catch (std::out_of_range& e) {
30707       {
30708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30709       };
30710     } catch (std::exception& e) {
30711       {
30712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30713       };
30714     } catch (...) {
30715       {
30716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30717       };
30718     }
30719   }
30720   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30721   return jresult;
30722 }
30723
30724
30725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30726   void * jresult ;
30727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30728   Dali::Vector3 result;
30729
30730   arg1 = (Dali::Actor *)jarg1;
30731   {
30732     try {
30733       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30734     } catch (std::out_of_range& e) {
30735       {
30736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30737       };
30738     } catch (std::exception& e) {
30739       {
30740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30741       };
30742     } catch (...) {
30743       {
30744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30745       };
30746     }
30747   }
30748   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30749   return jresult;
30750 }
30751
30752
30753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30755   bool arg2 ;
30756
30757   arg1 = (Dali::Actor *)jarg1;
30758   arg2 = jarg2 ? true : false;
30759   {
30760     try {
30761       (arg1)->SetInheritScale(arg2);
30762     } catch (std::out_of_range& e) {
30763       {
30764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30765       };
30766     } catch (std::exception& e) {
30767       {
30768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30769       };
30770     } catch (...) {
30771       {
30772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30773       };
30774     }
30775   }
30776 }
30777
30778
30779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30780   unsigned int jresult ;
30781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30782   bool result;
30783
30784   arg1 = (Dali::Actor *)jarg1;
30785   {
30786     try {
30787       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30788     } catch (std::out_of_range& e) {
30789       {
30790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30791       };
30792     } catch (std::exception& e) {
30793       {
30794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30795       };
30796     } catch (...) {
30797       {
30798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30799       };
30800     }
30801   }
30802   jresult = result;
30803   return jresult;
30804 }
30805
30806
30807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30808   void * jresult ;
30809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30810   Dali::Matrix result;
30811
30812   arg1 = (Dali::Actor *)jarg1;
30813   {
30814     try {
30815       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30816     } catch (std::out_of_range& e) {
30817       {
30818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30819       };
30820     } catch (std::exception& e) {
30821       {
30822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30823       };
30824     } catch (...) {
30825       {
30826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30827       };
30828     }
30829   }
30830   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30831   return jresult;
30832 }
30833
30834
30835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30837   bool arg2 ;
30838
30839   arg1 = (Dali::Actor *)jarg1;
30840   arg2 = jarg2 ? true : false;
30841   {
30842     try {
30843       (arg1)->SetVisible(arg2);
30844     } catch (std::out_of_range& e) {
30845       {
30846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30847       };
30848     } catch (std::exception& e) {
30849       {
30850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30851       };
30852     } catch (...) {
30853       {
30854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30855       };
30856     }
30857   }
30858 }
30859
30860
30861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30862   unsigned int jresult ;
30863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30864   bool result;
30865
30866   arg1 = (Dali::Actor *)jarg1;
30867   {
30868     try {
30869       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30870     } catch (std::out_of_range& e) {
30871       {
30872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30873       };
30874     } catch (std::exception& e) {
30875       {
30876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30877       };
30878     } catch (...) {
30879       {
30880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30881       };
30882     }
30883   }
30884   jresult = result;
30885   return jresult;
30886 }
30887
30888
30889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30891   float arg2 ;
30892
30893   arg1 = (Dali::Actor *)jarg1;
30894   arg2 = (float)jarg2;
30895   {
30896     try {
30897       (arg1)->SetOpacity(arg2);
30898     } catch (std::out_of_range& e) {
30899       {
30900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30901       };
30902     } catch (std::exception& e) {
30903       {
30904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30905       };
30906     } catch (...) {
30907       {
30908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30909       };
30910     }
30911   }
30912 }
30913
30914
30915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30916   float jresult ;
30917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30918   float result;
30919
30920   arg1 = (Dali::Actor *)jarg1;
30921   {
30922     try {
30923       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30924     } catch (std::out_of_range& e) {
30925       {
30926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30927       };
30928     } catch (std::exception& e) {
30929       {
30930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30931       };
30932     } catch (...) {
30933       {
30934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30935       };
30936     }
30937   }
30938   jresult = result;
30939   return jresult;
30940 }
30941
30942
30943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30945   Dali::Vector4 *arg2 = 0 ;
30946
30947   arg1 = (Dali::Actor *)jarg1;
30948   arg2 = (Dali::Vector4 *)jarg2;
30949   if (!arg2) {
30950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30951     return ;
30952   }
30953   {
30954     try {
30955       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30956     } catch (std::out_of_range& e) {
30957       {
30958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30959       };
30960     } catch (std::exception& e) {
30961       {
30962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30963       };
30964     } catch (...) {
30965       {
30966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30967       };
30968     }
30969   }
30970 }
30971
30972
30973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30974   void * jresult ;
30975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30976   Dali::Vector4 result;
30977
30978   arg1 = (Dali::Actor *)jarg1;
30979   {
30980     try {
30981       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30982     } catch (std::out_of_range& e) {
30983       {
30984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30985       };
30986     } catch (std::exception& e) {
30987       {
30988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30989       };
30990     } catch (...) {
30991       {
30992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30993       };
30994     }
30995   }
30996   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30997   return jresult;
30998 }
30999
31000
31001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31003   Dali::ColorMode arg2 ;
31004
31005   arg1 = (Dali::Actor *)jarg1;
31006   arg2 = (Dali::ColorMode)jarg2;
31007   {
31008     try {
31009       (arg1)->SetColorMode(arg2);
31010     } catch (std::out_of_range& e) {
31011       {
31012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31013       };
31014     } catch (std::exception& e) {
31015       {
31016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31017       };
31018     } catch (...) {
31019       {
31020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31021       };
31022     }
31023   }
31024 }
31025
31026
31027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31028   int jresult ;
31029   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31030   Dali::ColorMode result;
31031
31032   arg1 = (Dali::Actor *)jarg1;
31033   {
31034     try {
31035       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31036     } catch (std::out_of_range& e) {
31037       {
31038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31039       };
31040     } catch (std::exception& e) {
31041       {
31042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31043       };
31044     } catch (...) {
31045       {
31046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31047       };
31048     }
31049   }
31050   jresult = (int)result;
31051   return jresult;
31052 }
31053
31054
31055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31056   void * jresult ;
31057   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31058   Dali::Vector4 result;
31059
31060   arg1 = (Dali::Actor *)jarg1;
31061   {
31062     try {
31063       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31064     } catch (std::out_of_range& e) {
31065       {
31066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31067       };
31068     } catch (std::exception& e) {
31069       {
31070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (...) {
31073       {
31074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31075       };
31076     }
31077   }
31078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31079   return jresult;
31080 }
31081
31082
31083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31085   Dali::DrawMode::Type arg2 ;
31086
31087   arg1 = (Dali::Actor *)jarg1;
31088   arg2 = (Dali::DrawMode::Type)jarg2;
31089   {
31090     try {
31091       (arg1)->SetDrawMode(arg2);
31092     } catch (std::out_of_range& e) {
31093       {
31094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31095       };
31096     } catch (std::exception& e) {
31097       {
31098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31099       };
31100     } catch (...) {
31101       {
31102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31103       };
31104     }
31105   }
31106 }
31107
31108
31109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31110   int jresult ;
31111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31112   Dali::DrawMode::Type result;
31113
31114   arg1 = (Dali::Actor *)jarg1;
31115   {
31116     try {
31117       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31118     } catch (std::out_of_range& e) {
31119       {
31120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31121       };
31122     } catch (std::exception& e) {
31123       {
31124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31125       };
31126     } catch (...) {
31127       {
31128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31129       };
31130     }
31131   }
31132   jresult = (int)result;
31133   return jresult;
31134 }
31135
31136
31137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31139   bool arg2 ;
31140
31141   arg1 = (Dali::Actor *)jarg1;
31142   arg2 = jarg2 ? true : false;
31143   {
31144     try {
31145       (arg1)->SetSensitive(arg2);
31146     } catch (std::out_of_range& e) {
31147       {
31148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31149       };
31150     } catch (std::exception& e) {
31151       {
31152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31153       };
31154     } catch (...) {
31155       {
31156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31157       };
31158     }
31159   }
31160 }
31161
31162
31163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31164   unsigned int jresult ;
31165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31166   bool result;
31167
31168   arg1 = (Dali::Actor *)jarg1;
31169   {
31170     try {
31171       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31172     } catch (std::out_of_range& e) {
31173       {
31174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31175       };
31176     } catch (std::exception& e) {
31177       {
31178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31179       };
31180     } catch (...) {
31181       {
31182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31183       };
31184     }
31185   }
31186   jresult = result;
31187   return jresult;
31188 }
31189
31190
31191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31192   unsigned int jresult ;
31193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31194   float *arg2 = 0 ;
31195   float *arg3 = 0 ;
31196   float arg4 ;
31197   float arg5 ;
31198   bool result;
31199
31200   arg1 = (Dali::Actor *)jarg1;
31201   arg2 = (float *)jarg2;
31202   arg3 = (float *)jarg3;
31203   arg4 = (float)jarg4;
31204   arg5 = (float)jarg5;
31205   {
31206     try {
31207       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31208     } catch (std::out_of_range& e) {
31209       {
31210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31211       };
31212     } catch (std::exception& e) {
31213       {
31214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31215       };
31216     } catch (...) {
31217       {
31218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31219       };
31220     }
31221   }
31222   jresult = result;
31223   return jresult;
31224 }
31225
31226
31227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31229   bool arg2 ;
31230
31231   arg1 = (Dali::Actor *)jarg1;
31232   arg2 = jarg2 ? true : false;
31233   {
31234     try {
31235       (arg1)->SetLeaveRequired(arg2);
31236     } catch (std::out_of_range& e) {
31237       {
31238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31239       };
31240     } catch (std::exception& e) {
31241       {
31242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31243       };
31244     } catch (...) {
31245       {
31246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31247       };
31248     }
31249   }
31250 }
31251
31252
31253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31254   unsigned int jresult ;
31255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31256   bool result;
31257
31258   arg1 = (Dali::Actor *)jarg1;
31259   {
31260     try {
31261       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31262     } catch (std::out_of_range& e) {
31263       {
31264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31265       };
31266     } catch (std::exception& e) {
31267       {
31268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31269       };
31270     } catch (...) {
31271       {
31272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31273       };
31274     }
31275   }
31276   jresult = result;
31277   return jresult;
31278 }
31279
31280
31281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31283   bool arg2 ;
31284
31285   arg1 = (Dali::Actor *)jarg1;
31286   arg2 = jarg2 ? true : false;
31287   {
31288     try {
31289       (arg1)->SetKeyboardFocusable(arg2);
31290     } catch (std::out_of_range& e) {
31291       {
31292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31293       };
31294     } catch (std::exception& e) {
31295       {
31296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31297       };
31298     } catch (...) {
31299       {
31300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31301       };
31302     }
31303   }
31304 }
31305
31306
31307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31308   unsigned int jresult ;
31309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31310   bool result;
31311
31312   arg1 = (Dali::Actor *)jarg1;
31313   {
31314     try {
31315       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31316     } catch (std::out_of_range& e) {
31317       {
31318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31319       };
31320     } catch (std::exception& e) {
31321       {
31322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31323       };
31324     } catch (...) {
31325       {
31326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31327       };
31328     }
31329   }
31330   jresult = result;
31331   return jresult;
31332 }
31333
31334
31335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31337   Dali::ResizePolicy::Type arg2 ;
31338   Dali::Dimension::Type arg3 ;
31339
31340   arg1 = (Dali::Actor *)jarg1;
31341   arg2 = (Dali::ResizePolicy::Type)jarg2;
31342   arg3 = (Dali::Dimension::Type)jarg3;
31343   {
31344     try {
31345       (arg1)->SetResizePolicy(arg2,arg3);
31346     } catch (std::out_of_range& e) {
31347       {
31348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31349       };
31350     } catch (std::exception& e) {
31351       {
31352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31353       };
31354     } catch (...) {
31355       {
31356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31357       };
31358     }
31359   }
31360 }
31361
31362
31363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31364   int jresult ;
31365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31366   Dali::Dimension::Type arg2 ;
31367   Dali::ResizePolicy::Type result;
31368
31369   arg1 = (Dali::Actor *)jarg1;
31370   arg2 = (Dali::Dimension::Type)jarg2;
31371   {
31372     try {
31373       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31374     } catch (std::out_of_range& e) {
31375       {
31376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31377       };
31378     } catch (std::exception& e) {
31379       {
31380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31381       };
31382     } catch (...) {
31383       {
31384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31385       };
31386     }
31387   }
31388   jresult = (int)result;
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31395   Dali::SizeScalePolicy::Type arg2 ;
31396
31397   arg1 = (Dali::Actor *)jarg1;
31398   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31399   {
31400     try {
31401       (arg1)->SetSizeScalePolicy(arg2);
31402     } catch (std::out_of_range& e) {
31403       {
31404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31405       };
31406     } catch (std::exception& e) {
31407       {
31408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31409       };
31410     } catch (...) {
31411       {
31412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31413       };
31414     }
31415   }
31416 }
31417
31418
31419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31420   int jresult ;
31421   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31422   Dali::SizeScalePolicy::Type result;
31423
31424   arg1 = (Dali::Actor *)jarg1;
31425   {
31426     try {
31427       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31428     } catch (std::out_of_range& e) {
31429       {
31430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31431       };
31432     } catch (std::exception& e) {
31433       {
31434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31435       };
31436     } catch (...) {
31437       {
31438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31439       };
31440     }
31441   }
31442   jresult = (int)result;
31443   return jresult;
31444 }
31445
31446
31447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31449   Dali::Vector3 *arg2 = 0 ;
31450
31451   arg1 = (Dali::Actor *)jarg1;
31452   arg2 = (Dali::Vector3 *)jarg2;
31453   if (!arg2) {
31454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31455     return ;
31456   }
31457   {
31458     try {
31459       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31460     } catch (std::out_of_range& e) {
31461       {
31462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31463       };
31464     } catch (std::exception& e) {
31465       {
31466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31467       };
31468     } catch (...) {
31469       {
31470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31471       };
31472     }
31473   }
31474 }
31475
31476
31477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31478   void * jresult ;
31479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31480   Dali::Vector3 result;
31481
31482   arg1 = (Dali::Actor *)jarg1;
31483   {
31484     try {
31485       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31486     } catch (std::out_of_range& e) {
31487       {
31488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31489       };
31490     } catch (std::exception& e) {
31491       {
31492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (...) {
31495       {
31496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31497       };
31498     }
31499   }
31500   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31501   return jresult;
31502 }
31503
31504
31505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31506   float jresult ;
31507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31508   float arg2 ;
31509   float result;
31510
31511   arg1 = (Dali::Actor *)jarg1;
31512   arg2 = (float)jarg2;
31513   {
31514     try {
31515       result = (float)(arg1)->GetHeightForWidth(arg2);
31516     } catch (std::out_of_range& e) {
31517       {
31518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31519       };
31520     } catch (std::exception& e) {
31521       {
31522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31523       };
31524     } catch (...) {
31525       {
31526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31527       };
31528     }
31529   }
31530   jresult = result;
31531   return jresult;
31532 }
31533
31534
31535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31536   float jresult ;
31537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31538   float arg2 ;
31539   float result;
31540
31541   arg1 = (Dali::Actor *)jarg1;
31542   arg2 = (float)jarg2;
31543   {
31544     try {
31545       result = (float)(arg1)->GetWidthForHeight(arg2);
31546     } catch (std::out_of_range& e) {
31547       {
31548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31549       };
31550     } catch (std::exception& e) {
31551       {
31552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31553       };
31554     } catch (...) {
31555       {
31556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31557       };
31558     }
31559   }
31560   jresult = result;
31561   return jresult;
31562 }
31563
31564
31565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31566   float jresult ;
31567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31568   Dali::Dimension::Type arg2 ;
31569   float result;
31570
31571   arg1 = (Dali::Actor *)jarg1;
31572   arg2 = (Dali::Dimension::Type)jarg2;
31573   {
31574     try {
31575       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31576     } catch (std::out_of_range& e) {
31577       {
31578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31579       };
31580     } catch (std::exception& e) {
31581       {
31582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31583       };
31584     } catch (...) {
31585       {
31586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31587       };
31588     }
31589   }
31590   jresult = result;
31591   return jresult;
31592 }
31593
31594
31595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31597   Dali::Padding *arg2 = 0 ;
31598
31599   arg1 = (Dali::Actor *)jarg1;
31600   arg2 = (Dali::Padding *)jarg2;
31601   if (!arg2) {
31602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31603     return ;
31604   }
31605   {
31606     try {
31607       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31608     } catch (std::out_of_range& e) {
31609       {
31610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31611       };
31612     } catch (std::exception& e) {
31613       {
31614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31615       };
31616     } catch (...) {
31617       {
31618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31619       };
31620     }
31621   }
31622 }
31623
31624
31625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31627   Dali::Padding *arg2 = 0 ;
31628
31629   arg1 = (Dali::Actor *)jarg1;
31630   arg2 = (Dali::Padding *)jarg2;
31631   if (!arg2) {
31632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31633     return ;
31634   }
31635   {
31636     try {
31637       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31638     } catch (std::out_of_range& e) {
31639       {
31640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31641       };
31642     } catch (std::exception& e) {
31643       {
31644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31645       };
31646     } catch (...) {
31647       {
31648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31649       };
31650     }
31651   }
31652 }
31653
31654
31655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31657   Dali::Vector2 *arg2 = 0 ;
31658
31659   arg1 = (Dali::Actor *)jarg1;
31660   arg2 = (Dali::Vector2 *)jarg2;
31661   if (!arg2) {
31662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31663     return ;
31664   }
31665   {
31666     try {
31667       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31668     } catch (std::out_of_range& e) {
31669       {
31670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31671       };
31672     } catch (std::exception& e) {
31673       {
31674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31675       };
31676     } catch (...) {
31677       {
31678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31679       };
31680     }
31681   }
31682 }
31683
31684
31685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31686   void * jresult ;
31687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31688   Dali::Vector2 result;
31689
31690   arg1 = (Dali::Actor *)jarg1;
31691   {
31692     try {
31693       result = (arg1)->GetMinimumSize();
31694     } catch (std::out_of_range& e) {
31695       {
31696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31697       };
31698     } catch (std::exception& e) {
31699       {
31700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31701       };
31702     } catch (...) {
31703       {
31704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31705       };
31706     }
31707   }
31708   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31709   return jresult;
31710 }
31711
31712
31713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31715   Dali::Vector2 *arg2 = 0 ;
31716
31717   arg1 = (Dali::Actor *)jarg1;
31718   arg2 = (Dali::Vector2 *)jarg2;
31719   if (!arg2) {
31720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31721     return ;
31722   }
31723   {
31724     try {
31725       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31726     } catch (std::out_of_range& e) {
31727       {
31728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (std::exception& e) {
31731       {
31732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31737       };
31738     }
31739   }
31740 }
31741
31742
31743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31744   void * jresult ;
31745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31746   Dali::Vector2 result;
31747
31748   arg1 = (Dali::Actor *)jarg1;
31749   {
31750     try {
31751       result = (arg1)->GetMaximumSize();
31752     } catch (std::out_of_range& e) {
31753       {
31754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31755       };
31756     } catch (std::exception& e) {
31757       {
31758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31759       };
31760     } catch (...) {
31761       {
31762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31763       };
31764     }
31765   }
31766   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31767   return jresult;
31768 }
31769
31770
31771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31772   int jresult ;
31773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31774   int result;
31775
31776   arg1 = (Dali::Actor *)jarg1;
31777   {
31778     try {
31779       result = (int)(arg1)->GetHierarchyDepth();
31780     } catch (std::out_of_range& e) {
31781       {
31782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31783       };
31784     } catch (std::exception& e) {
31785       {
31786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31787       };
31788     } catch (...) {
31789       {
31790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31791       };
31792     }
31793   }
31794   jresult = result;
31795   return jresult;
31796 }
31797
31798
31799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31800   unsigned int jresult ;
31801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31802   Dali::Renderer *arg2 = 0 ;
31803   unsigned int result;
31804
31805   arg1 = (Dali::Actor *)jarg1;
31806   arg2 = (Dali::Renderer *)jarg2;
31807   if (!arg2) {
31808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31809     return 0;
31810   }
31811   {
31812     try {
31813       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31814     } catch (std::out_of_range& e) {
31815       {
31816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31817       };
31818     } catch (std::exception& e) {
31819       {
31820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31821       };
31822     } catch (...) {
31823       {
31824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31825       };
31826     }
31827   }
31828   jresult = result;
31829   return jresult;
31830 }
31831
31832
31833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31834   unsigned int jresult ;
31835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31836   unsigned int result;
31837
31838   arg1 = (Dali::Actor *)jarg1;
31839   {
31840     try {
31841       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31842     } catch (std::out_of_range& e) {
31843       {
31844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (std::exception& e) {
31847       {
31848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856   jresult = result;
31857   return jresult;
31858 }
31859
31860
31861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31862   void * jresult ;
31863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31864   unsigned int arg2 ;
31865   Dali::Renderer result;
31866
31867   arg1 = (Dali::Actor *)jarg1;
31868   arg2 = (unsigned int)jarg2;
31869   {
31870     try {
31871       result = (arg1)->GetRendererAt(arg2);
31872     } catch (std::out_of_range& e) {
31873       {
31874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (std::exception& e) {
31877       {
31878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31887   return jresult;
31888 }
31889
31890
31891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31893   Dali::Renderer *arg2 = 0 ;
31894
31895   arg1 = (Dali::Actor *)jarg1;
31896   arg2 = (Dali::Renderer *)jarg2;
31897   if (!arg2) {
31898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31899     return ;
31900   }
31901   {
31902     try {
31903       (arg1)->RemoveRenderer(*arg2);
31904     } catch (std::out_of_range& e) {
31905       {
31906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31907       };
31908     } catch (std::exception& e) {
31909       {
31910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31915       };
31916     }
31917   }
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31923   unsigned int arg2 ;
31924
31925   arg1 = (Dali::Actor *)jarg1;
31926   arg2 = (unsigned int)jarg2;
31927   {
31928     try {
31929       (arg1)->RemoveRenderer(arg2);
31930     } catch (std::out_of_range& e) {
31931       {
31932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31933       };
31934     } catch (std::exception& e) {
31935       {
31936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31941       };
31942     }
31943   }
31944 }
31945
31946
31947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31948   void * jresult ;
31949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31950   Dali::Actor::TouchSignalType *result = 0 ;
31951
31952   arg1 = (Dali::Actor *)jarg1;
31953   {
31954     try {
31955       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31956     } catch (std::out_of_range& e) {
31957       {
31958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31959       };
31960     } catch (std::exception& e) {
31961       {
31962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31963       };
31964     } catch (...) {
31965       {
31966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31967       };
31968     }
31969   }
31970   jresult = (void *)result;
31971   return jresult;
31972 }
31973
31974
31975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31976   void * jresult ;
31977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31978   Dali::Actor::TouchDataSignalType *result = 0 ;
31979
31980   arg1 = (Dali::Actor *)jarg1;
31981   {
31982     try {
31983       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31984     } catch (std::out_of_range& e) {
31985       {
31986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31987       };
31988     } catch (std::exception& e) {
31989       {
31990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31991       };
31992     } catch (...) {
31993       {
31994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31995       };
31996     }
31997   }
31998   jresult = (void *)result;
31999   return jresult;
32000 }
32001
32002
32003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32004   void * jresult ;
32005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32006   Dali::Actor::HoverSignalType *result = 0 ;
32007
32008   arg1 = (Dali::Actor *)jarg1;
32009   {
32010     try {
32011       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32012     } catch (std::out_of_range& e) {
32013       {
32014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32015       };
32016     } catch (std::exception& e) {
32017       {
32018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (...) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32023       };
32024     }
32025   }
32026   jresult = (void *)result;
32027   return jresult;
32028 }
32029
32030
32031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32032   void * jresult ;
32033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32034   Dali::Actor::WheelEventSignalType *result = 0 ;
32035
32036   arg1 = (Dali::Actor *)jarg1;
32037   {
32038     try {
32039       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32040     } catch (std::out_of_range& e) {
32041       {
32042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32043       };
32044     } catch (std::exception& e) {
32045       {
32046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32047       };
32048     } catch (...) {
32049       {
32050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32051       };
32052     }
32053   }
32054   jresult = (void *)result;
32055   return jresult;
32056 }
32057
32058
32059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32060   void * jresult ;
32061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32062   Dali::Actor::OnStageSignalType *result = 0 ;
32063
32064   arg1 = (Dali::Actor *)jarg1;
32065   {
32066     try {
32067       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (...) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32079       };
32080     }
32081   }
32082   jresult = (void *)result;
32083   return jresult;
32084 }
32085
32086
32087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32088   void * jresult ;
32089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32090   Dali::Actor::OffStageSignalType *result = 0 ;
32091
32092   arg1 = (Dali::Actor *)jarg1;
32093   {
32094     try {
32095       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32096     } catch (std::out_of_range& e) {
32097       {
32098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (std::exception& e) {
32101       {
32102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (...) {
32105       {
32106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32107       };
32108     }
32109   }
32110   jresult = (void *)result;
32111   return jresult;
32112 }
32113
32114
32115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32116   void * jresult ;
32117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32118   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32119
32120   arg1 = (Dali::Actor *)jarg1;
32121   {
32122     try {
32123       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32124     } catch (std::out_of_range& e) {
32125       {
32126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32127       };
32128     } catch (std::exception& e) {
32129       {
32130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32131       };
32132     } catch (...) {
32133       {
32134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32135       };
32136     }
32137   }
32138   jresult = (void *)result;
32139   return jresult;
32140 }
32141
32142
32143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32144   Dali::Actor *arg1 = 0 ;
32145
32146   arg1 = (Dali::Actor *)jarg1;
32147   if (!arg1) {
32148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32149     return ;
32150   }
32151   {
32152     try {
32153       Dali::UnparentAndReset(*arg1);
32154     } catch (std::out_of_range& e) {
32155       {
32156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32157       };
32158     } catch (std::exception& e) {
32159       {
32160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32161       };
32162     } catch (...) {
32163       {
32164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32165       };
32166     }
32167   }
32168 }
32169
32170
32171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32172   Dali::Actor arg1 ;
32173   Dali::Actor *argp1 ;
32174
32175   argp1 = (Dali::Actor *)jarg1;
32176   if (!argp1) {
32177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32178     return ;
32179   }
32180   arg1 = *argp1;
32181   {
32182     try {
32183       Dali::DevelActor::Raise(arg1);
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32191       };
32192     } catch (...) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32195       };
32196     }
32197   }
32198 }
32199
32200
32201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32202   Dali::Actor arg1 ;
32203   Dali::Actor *argp1 ;
32204
32205   argp1 = (Dali::Actor *)jarg1;
32206   if (!argp1) {
32207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32208     return ;
32209   }
32210   arg1 = *argp1;
32211   {
32212     try {
32213       Dali::DevelActor::Lower(arg1);
32214     } catch (std::out_of_range& e) {
32215       {
32216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32217       };
32218     } catch (std::exception& e) {
32219       {
32220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32221       };
32222     } catch (...) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32225       };
32226     }
32227   }
32228 }
32229
32230
32231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32232   Dali::Actor arg1 ;
32233   Dali::Actor *argp1 ;
32234
32235   argp1 = (Dali::Actor *)jarg1;
32236   if (!argp1) {
32237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32238     return ;
32239   }
32240   arg1 = *argp1;
32241   {
32242     try {
32243       Dali::DevelActor::RaiseToTop(arg1);
32244     } catch (std::out_of_range& e) {
32245       {
32246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32247       };
32248     } catch (std::exception& e) {
32249       {
32250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32251       };
32252     } catch (...) {
32253       {
32254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32255       };
32256     }
32257   }
32258 }
32259
32260
32261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32262   Dali::Actor arg1 ;
32263   Dali::Actor *argp1 ;
32264
32265   argp1 = (Dali::Actor *)jarg1;
32266   if (!argp1) {
32267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32268     return ;
32269   }
32270   arg1 = *argp1;
32271   {
32272     try {
32273       Dali::DevelActor::LowerToBottom(arg1);
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (...) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32285       };
32286     }
32287   }
32288 }
32289
32290
32291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32292   Dali::Actor arg1 ;
32293   Dali::Actor arg2 ;
32294   Dali::Actor *argp1 ;
32295   Dali::Actor *argp2 ;
32296
32297   argp1 = (Dali::Actor *)jarg1;
32298   if (!argp1) {
32299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32300     return ;
32301   }
32302   arg1 = *argp1;
32303   argp2 = (Dali::Actor *)jarg2;
32304   if (!argp2) {
32305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32306     return ;
32307   }
32308   arg2 = *argp2;
32309   {
32310     try {
32311       Dali::DevelActor::RaiseAbove(arg1,arg2);
32312     } catch (std::out_of_range& e) {
32313       {
32314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32315       };
32316     } catch (std::exception& e) {
32317       {
32318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32319       };
32320     } catch (...) {
32321       {
32322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32323       };
32324     }
32325   }
32326 }
32327
32328
32329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32330   Dali::Actor arg1 ;
32331   Dali::Actor arg2 ;
32332   Dali::Actor *argp1 ;
32333   Dali::Actor *argp2 ;
32334
32335   argp1 = (Dali::Actor *)jarg1;
32336   if (!argp1) {
32337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32338     return ;
32339   }
32340   arg1 = *argp1;
32341   argp2 = (Dali::Actor *)jarg2;
32342   if (!argp2) {
32343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32344     return ;
32345   }
32346   arg2 = *argp2;
32347   {
32348     try {
32349       Dali::DevelActor::LowerBelow(arg1,arg2);
32350     } catch (std::out_of_range& e) {
32351       {
32352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32353       };
32354     } catch (std::exception& e) {
32355       {
32356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32361       };
32362     }
32363   }
32364 }
32365
32366
32367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32368   int jresult ;
32369   int result;
32370
32371   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32372   jresult = (int)result;
32373   return jresult;
32374 }
32375
32376
32377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32378   int jresult ;
32379   int result;
32380
32381   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32382   jresult = (int)result;
32383   return jresult;
32384 }
32385
32386
32387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32388   int jresult ;
32389   int result;
32390
32391   result = (int)Dali::Layer::Property::BEHAVIOR;
32392   jresult = (int)result;
32393   return jresult;
32394 }
32395
32396
32397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32398   void * jresult ;
32399   Dali::Layer::Property *result = 0 ;
32400
32401   {
32402     try {
32403       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32404     } catch (std::out_of_range& e) {
32405       {
32406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32407       };
32408     } catch (std::exception& e) {
32409       {
32410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32411       };
32412     } catch (...) {
32413       {
32414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32415       };
32416     }
32417   }
32418   jresult = (void *)result;
32419   return jresult;
32420 }
32421
32422
32423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32424   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32425
32426   arg1 = (Dali::Layer::Property *)jarg1;
32427   {
32428     try {
32429       delete arg1;
32430     } catch (std::out_of_range& e) {
32431       {
32432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32433       };
32434     } catch (std::exception& e) {
32435       {
32436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32437       };
32438     } catch (...) {
32439       {
32440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32441       };
32442     }
32443   }
32444 }
32445
32446
32447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32448   void * jresult ;
32449   Dali::Layer *result = 0 ;
32450
32451   {
32452     try {
32453       result = (Dali::Layer *)new Dali::Layer();
32454     } catch (std::out_of_range& e) {
32455       {
32456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32457       };
32458     } catch (std::exception& e) {
32459       {
32460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32461       };
32462     } catch (...) {
32463       {
32464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32465       };
32466     }
32467   }
32468   jresult = (void *)result;
32469   return jresult;
32470 }
32471
32472
32473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32474   void * jresult ;
32475   Dali::Layer result;
32476
32477   {
32478     try {
32479       result = Dali::Layer::New();
32480     } catch (std::out_of_range& e) {
32481       {
32482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32483       };
32484     } catch (std::exception& e) {
32485       {
32486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (...) {
32489       {
32490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32491       };
32492     }
32493   }
32494   jresult = new Dali::Layer((const Dali::Layer &)result);
32495   return jresult;
32496 }
32497
32498
32499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32500   void * jresult ;
32501   Dali::BaseHandle arg1 ;
32502   Dali::BaseHandle *argp1 ;
32503   Dali::Layer result;
32504
32505   argp1 = (Dali::BaseHandle *)jarg1;
32506   if (!argp1) {
32507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32508     return 0;
32509   }
32510   arg1 = *argp1;
32511   {
32512     try {
32513       result = Dali::Layer::DownCast(arg1);
32514     } catch (std::out_of_range& e) {
32515       {
32516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32517       };
32518     } catch (std::exception& e) {
32519       {
32520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32521       };
32522     } catch (...) {
32523       {
32524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32525       };
32526     }
32527   }
32528   jresult = new Dali::Layer((const Dali::Layer &)result);
32529   return jresult;
32530 }
32531
32532
32533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32534   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32535
32536   arg1 = (Dali::Layer *)jarg1;
32537   {
32538     try {
32539       delete arg1;
32540     } catch (std::out_of_range& e) {
32541       {
32542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32543       };
32544     } catch (std::exception& e) {
32545       {
32546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32547       };
32548     } catch (...) {
32549       {
32550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32551       };
32552     }
32553   }
32554 }
32555
32556
32557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32558   void * jresult ;
32559   Dali::Layer *arg1 = 0 ;
32560   Dali::Layer *result = 0 ;
32561
32562   arg1 = (Dali::Layer *)jarg1;
32563   if (!arg1) {
32564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32565     return 0;
32566   }
32567   {
32568     try {
32569       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32570     } catch (std::out_of_range& e) {
32571       {
32572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32573       };
32574     } catch (std::exception& e) {
32575       {
32576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32577       };
32578     } catch (...) {
32579       {
32580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32581       };
32582     }
32583   }
32584   jresult = (void *)result;
32585   return jresult;
32586 }
32587
32588
32589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32590   void * jresult ;
32591   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32592   Dali::Layer *arg2 = 0 ;
32593   Dali::Layer *result = 0 ;
32594
32595   arg1 = (Dali::Layer *)jarg1;
32596   arg2 = (Dali::Layer *)jarg2;
32597   if (!arg2) {
32598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32599     return 0;
32600   }
32601   {
32602     try {
32603       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32604     } catch (std::out_of_range& e) {
32605       {
32606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32607       };
32608     } catch (std::exception& e) {
32609       {
32610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32611       };
32612     } catch (...) {
32613       {
32614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32615       };
32616     }
32617   }
32618   jresult = (void *)result;
32619   return jresult;
32620 }
32621
32622
32623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32624   unsigned int jresult ;
32625   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32626   unsigned int result;
32627
32628   arg1 = (Dali::Layer *)jarg1;
32629   {
32630     try {
32631       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32632     } catch (std::out_of_range& e) {
32633       {
32634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32635       };
32636     } catch (std::exception& e) {
32637       {
32638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32639       };
32640     } catch (...) {
32641       {
32642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32643       };
32644     }
32645   }
32646   jresult = result;
32647   return jresult;
32648 }
32649
32650
32651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32652   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32653
32654   arg1 = (Dali::Layer *)jarg1;
32655   {
32656     try {
32657       (arg1)->Raise();
32658     } catch (std::out_of_range& e) {
32659       {
32660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32661       };
32662     } catch (std::exception& e) {
32663       {
32664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (...) {
32667       {
32668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32669       };
32670     }
32671   }
32672 }
32673
32674
32675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32676   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32677
32678   arg1 = (Dali::Layer *)jarg1;
32679   {
32680     try {
32681       (arg1)->Lower();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (...) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32693       };
32694     }
32695   }
32696 }
32697
32698
32699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32700   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32701   Dali::Layer arg2 ;
32702   Dali::Layer *argp2 ;
32703
32704   arg1 = (Dali::Layer *)jarg1;
32705   argp2 = (Dali::Layer *)jarg2;
32706   if (!argp2) {
32707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32708     return ;
32709   }
32710   arg2 = *argp2;
32711   {
32712     try {
32713       (arg1)->RaiseAbove(arg2);
32714     } catch (std::out_of_range& e) {
32715       {
32716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32717       };
32718     } catch (std::exception& e) {
32719       {
32720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32721       };
32722     } catch (...) {
32723       {
32724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32725       };
32726     }
32727   }
32728 }
32729
32730
32731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32732   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32733   Dali::Layer arg2 ;
32734   Dali::Layer *argp2 ;
32735
32736   arg1 = (Dali::Layer *)jarg1;
32737   argp2 = (Dali::Layer *)jarg2;
32738   if (!argp2) {
32739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32740     return ;
32741   }
32742   arg2 = *argp2;
32743   {
32744     try {
32745       (arg1)->LowerBelow(arg2);
32746     } catch (std::out_of_range& e) {
32747       {
32748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (std::exception& e) {
32751       {
32752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32753       };
32754     } catch (...) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32757       };
32758     }
32759   }
32760 }
32761
32762
32763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32764   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32765
32766   arg1 = (Dali::Layer *)jarg1;
32767   {
32768     try {
32769       (arg1)->RaiseToTop();
32770     } catch (std::out_of_range& e) {
32771       {
32772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32773       };
32774     } catch (std::exception& e) {
32775       {
32776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32777       };
32778     } catch (...) {
32779       {
32780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32781       };
32782     }
32783   }
32784 }
32785
32786
32787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32788   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32789
32790   arg1 = (Dali::Layer *)jarg1;
32791   {
32792     try {
32793       (arg1)->LowerToBottom();
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (...) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32805       };
32806     }
32807   }
32808 }
32809
32810
32811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32812   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32813   Dali::Layer arg2 ;
32814   Dali::Layer *argp2 ;
32815
32816   arg1 = (Dali::Layer *)jarg1;
32817   argp2 = (Dali::Layer *)jarg2;
32818   if (!argp2) {
32819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32820     return ;
32821   }
32822   arg2 = *argp2;
32823   {
32824     try {
32825       (arg1)->MoveAbove(arg2);
32826     } catch (std::out_of_range& e) {
32827       {
32828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32829       };
32830     } catch (std::exception& e) {
32831       {
32832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32833       };
32834     } catch (...) {
32835       {
32836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32837       };
32838     }
32839   }
32840 }
32841
32842
32843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32844   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32845   Dali::Layer arg2 ;
32846   Dali::Layer *argp2 ;
32847
32848   arg1 = (Dali::Layer *)jarg1;
32849   argp2 = (Dali::Layer *)jarg2;
32850   if (!argp2) {
32851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32852     return ;
32853   }
32854   arg2 = *argp2;
32855   {
32856     try {
32857       (arg1)->MoveBelow(arg2);
32858     } catch (std::out_of_range& e) {
32859       {
32860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32861       };
32862     } catch (std::exception& e) {
32863       {
32864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32865       };
32866     } catch (...) {
32867       {
32868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32869       };
32870     }
32871   }
32872 }
32873
32874
32875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32876   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32877   Dali::Layer::Behavior arg2 ;
32878
32879   arg1 = (Dali::Layer *)jarg1;
32880   arg2 = (Dali::Layer::Behavior)jarg2;
32881   {
32882     try {
32883       (arg1)->SetBehavior(arg2);
32884     } catch (std::out_of_range& e) {
32885       {
32886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32887       };
32888     } catch (std::exception& e) {
32889       {
32890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32891       };
32892     } catch (...) {
32893       {
32894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32895       };
32896     }
32897   }
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32902   int jresult ;
32903   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32904   Dali::Layer::Behavior result;
32905
32906   arg1 = (Dali::Layer *)jarg1;
32907   {
32908     try {
32909       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32910     } catch (std::out_of_range& e) {
32911       {
32912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32913       };
32914     } catch (std::exception& e) {
32915       {
32916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32917       };
32918     } catch (...) {
32919       {
32920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32921       };
32922     }
32923   }
32924   jresult = (int)result;
32925   return jresult;
32926 }
32927
32928
32929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32930   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32931   bool arg2 ;
32932
32933   arg1 = (Dali::Layer *)jarg1;
32934   arg2 = jarg2 ? true : false;
32935   {
32936     try {
32937       (arg1)->SetClipping(arg2);
32938     } catch (std::out_of_range& e) {
32939       {
32940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32941       };
32942     } catch (std::exception& e) {
32943       {
32944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32945       };
32946     } catch (...) {
32947       {
32948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32949       };
32950     }
32951   }
32952 }
32953
32954
32955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32956   unsigned int jresult ;
32957   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32958   bool result;
32959
32960   arg1 = (Dali::Layer *)jarg1;
32961   {
32962     try {
32963       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32964     } catch (std::out_of_range& e) {
32965       {
32966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32967       };
32968     } catch (std::exception& e) {
32969       {
32970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32971       };
32972     } catch (...) {
32973       {
32974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32975       };
32976     }
32977   }
32978   jresult = result;
32979   return jresult;
32980 }
32981
32982
32983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32985   int arg2 ;
32986   int arg3 ;
32987   int arg4 ;
32988   int arg5 ;
32989
32990   arg1 = (Dali::Layer *)jarg1;
32991   arg2 = (int)jarg2;
32992   arg3 = (int)jarg3;
32993   arg4 = (int)jarg4;
32994   arg5 = (int)jarg5;
32995   {
32996     try {
32997       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32998     } catch (std::out_of_range& e) {
32999       {
33000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33001       };
33002     } catch (std::exception& e) {
33003       {
33004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33005       };
33006     } catch (...) {
33007       {
33008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33009       };
33010     }
33011   }
33012 }
33013
33014
33015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33016   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33017   Dali::ClippingBox arg2 ;
33018   Dali::ClippingBox *argp2 ;
33019
33020   arg1 = (Dali::Layer *)jarg1;
33021   argp2 = (Dali::ClippingBox *)jarg2;
33022   if (!argp2) {
33023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33024     return ;
33025   }
33026   arg2 = *argp2;
33027   {
33028     try {
33029       (arg1)->SetClippingBox(arg2);
33030     } catch (std::out_of_range& e) {
33031       {
33032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33033       };
33034     } catch (std::exception& e) {
33035       {
33036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33037       };
33038     } catch (...) {
33039       {
33040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33041       };
33042     }
33043   }
33044 }
33045
33046
33047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33048   void * jresult ;
33049   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33050   Dali::ClippingBox result;
33051
33052   arg1 = (Dali::Layer *)jarg1;
33053   {
33054     try {
33055       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33056     } catch (std::out_of_range& e) {
33057       {
33058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33059       };
33060     } catch (std::exception& e) {
33061       {
33062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33063       };
33064     } catch (...) {
33065       {
33066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33067       };
33068     }
33069   }
33070   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33071   return jresult;
33072 }
33073
33074
33075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33076   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33077   bool arg2 ;
33078
33079   arg1 = (Dali::Layer *)jarg1;
33080   arg2 = jarg2 ? true : false;
33081   {
33082     try {
33083       (arg1)->SetDepthTestDisabled(arg2);
33084     } catch (std::out_of_range& e) {
33085       {
33086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33087       };
33088     } catch (std::exception& e) {
33089       {
33090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33091       };
33092     } catch (...) {
33093       {
33094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33095       };
33096     }
33097   }
33098 }
33099
33100
33101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33102   unsigned int jresult ;
33103   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33104   bool result;
33105
33106   arg1 = (Dali::Layer *)jarg1;
33107   {
33108     try {
33109       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33110     } catch (std::out_of_range& e) {
33111       {
33112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33113       };
33114     } catch (std::exception& e) {
33115       {
33116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33117       };
33118     } catch (...) {
33119       {
33120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33121       };
33122     }
33123   }
33124   jresult = result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33130   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33131   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33132
33133   arg1 = (Dali::Layer *)jarg1;
33134   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33135   {
33136     try {
33137       (arg1)->SetSortFunction(arg2);
33138     } catch (std::out_of_range& e) {
33139       {
33140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33141       };
33142     } catch (std::exception& e) {
33143       {
33144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33145       };
33146     } catch (...) {
33147       {
33148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33149       };
33150     }
33151   }
33152 }
33153
33154
33155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33156   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33157   bool arg2 ;
33158
33159   arg1 = (Dali::Layer *)jarg1;
33160   arg2 = jarg2 ? true : false;
33161   {
33162     try {
33163       (arg1)->SetTouchConsumed(arg2);
33164     } catch (std::out_of_range& e) {
33165       {
33166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33167       };
33168     } catch (std::exception& e) {
33169       {
33170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33171       };
33172     } catch (...) {
33173       {
33174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33175       };
33176     }
33177   }
33178 }
33179
33180
33181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33182   unsigned int jresult ;
33183   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33184   bool result;
33185
33186   arg1 = (Dali::Layer *)jarg1;
33187   {
33188     try {
33189       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33190     } catch (std::out_of_range& e) {
33191       {
33192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33193       };
33194     } catch (std::exception& e) {
33195       {
33196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33197       };
33198     } catch (...) {
33199       {
33200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33201       };
33202     }
33203   }
33204   jresult = result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33210   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33211   bool arg2 ;
33212
33213   arg1 = (Dali::Layer *)jarg1;
33214   arg2 = jarg2 ? true : false;
33215   {
33216     try {
33217       (arg1)->SetHoverConsumed(arg2);
33218     } catch (std::out_of_range& e) {
33219       {
33220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33221       };
33222     } catch (std::exception& e) {
33223       {
33224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33225       };
33226     } catch (...) {
33227       {
33228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33229       };
33230     }
33231   }
33232 }
33233
33234
33235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33236   unsigned int jresult ;
33237   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33238   bool result;
33239
33240   arg1 = (Dali::Layer *)jarg1;
33241   {
33242     try {
33243       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33244     } catch (std::out_of_range& e) {
33245       {
33246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33247       };
33248     } catch (std::exception& e) {
33249       {
33250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33251       };
33252     } catch (...) {
33253       {
33254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33255       };
33256     }
33257   }
33258   jresult = result;
33259   return jresult;
33260 }
33261
33262
33263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33264   void * jresult ;
33265   Dali::Vector4 *result = 0 ;
33266
33267   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33268   jresult = (void *)result;
33269   return jresult;
33270 }
33271
33272
33273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33274   void * jresult ;
33275   Dali::Vector4 *result = 0 ;
33276
33277   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33278   jresult = (void *)result;
33279   return jresult;
33280 }
33281
33282
33283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33284   void * jresult ;
33285   Dali::Stage *result = 0 ;
33286
33287   {
33288     try {
33289       result = (Dali::Stage *)new Dali::Stage();
33290     } catch (std::out_of_range& e) {
33291       {
33292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33293       };
33294     } catch (std::exception& e) {
33295       {
33296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (...) {
33299       {
33300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33301       };
33302     }
33303   }
33304   jresult = (void *)result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33310   void * jresult ;
33311   Dali::Stage result;
33312
33313   {
33314     try {
33315       result = Dali::Stage::GetCurrent();
33316     } catch (std::out_of_range& e) {
33317       {
33318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33319       };
33320     } catch (std::exception& e) {
33321       {
33322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33323       };
33324     } catch (...) {
33325       {
33326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33327       };
33328     }
33329   }
33330   jresult = new Dali::Stage((const Dali::Stage &)result);
33331   return jresult;
33332 }
33333
33334
33335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33336   unsigned int jresult ;
33337   bool result;
33338
33339   {
33340     try {
33341       result = (bool)Dali::Stage::IsInstalled();
33342     } catch (std::out_of_range& e) {
33343       {
33344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33345       };
33346     } catch (std::exception& e) {
33347       {
33348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33349       };
33350     } catch (...) {
33351       {
33352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33353       };
33354     }
33355   }
33356   jresult = result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33362   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33363
33364   arg1 = (Dali::Stage *)jarg1;
33365   {
33366     try {
33367       delete arg1;
33368     } catch (std::out_of_range& e) {
33369       {
33370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33371       };
33372     } catch (std::exception& e) {
33373       {
33374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33375       };
33376     } catch (...) {
33377       {
33378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33379       };
33380     }
33381   }
33382 }
33383
33384
33385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33386   void * jresult ;
33387   Dali::Stage *arg1 = 0 ;
33388   Dali::Stage *result = 0 ;
33389
33390   arg1 = (Dali::Stage *)jarg1;
33391   if (!arg1) {
33392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33393     return 0;
33394   }
33395   {
33396     try {
33397       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33398     } catch (std::out_of_range& e) {
33399       {
33400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33401       };
33402     } catch (std::exception& e) {
33403       {
33404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33405       };
33406     } catch (...) {
33407       {
33408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33409       };
33410     }
33411   }
33412   jresult = (void *)result;
33413   return jresult;
33414 }
33415
33416
33417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33418   void * jresult ;
33419   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33420   Dali::Stage *arg2 = 0 ;
33421   Dali::Stage *result = 0 ;
33422
33423   arg1 = (Dali::Stage *)jarg1;
33424   arg2 = (Dali::Stage *)jarg2;
33425   if (!arg2) {
33426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33427     return 0;
33428   }
33429   {
33430     try {
33431       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33432     } catch (std::out_of_range& e) {
33433       {
33434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33435       };
33436     } catch (std::exception& e) {
33437       {
33438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33439       };
33440     } catch (...) {
33441       {
33442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33443       };
33444     }
33445   }
33446   jresult = (void *)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33452   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33453   Dali::Actor *arg2 = 0 ;
33454
33455   arg1 = (Dali::Stage *)jarg1;
33456   arg2 = (Dali::Actor *)jarg2;
33457   if (!arg2) {
33458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33459     return ;
33460   }
33461   {
33462     try {
33463       (arg1)->Add(*arg2);
33464     } catch (std::out_of_range& e) {
33465       {
33466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33467       };
33468     } catch (std::exception& e) {
33469       {
33470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33471       };
33472     } catch (...) {
33473       {
33474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33475       };
33476     }
33477   }
33478 }
33479
33480
33481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33482   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33483   Dali::Actor *arg2 = 0 ;
33484
33485   arg1 = (Dali::Stage *)jarg1;
33486   arg2 = (Dali::Actor *)jarg2;
33487   if (!arg2) {
33488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33489     return ;
33490   }
33491   {
33492     try {
33493       (arg1)->Remove(*arg2);
33494     } catch (std::out_of_range& e) {
33495       {
33496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33497       };
33498     } catch (std::exception& e) {
33499       {
33500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33501       };
33502     } catch (...) {
33503       {
33504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33505       };
33506     }
33507   }
33508 }
33509
33510
33511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33512   void * jresult ;
33513   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33514   Dali::Vector2 result;
33515
33516   arg1 = (Dali::Stage *)jarg1;
33517   {
33518     try {
33519       result = ((Dali::Stage const *)arg1)->GetSize();
33520     } catch (std::out_of_range& e) {
33521       {
33522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33523       };
33524     } catch (std::exception& e) {
33525       {
33526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33527       };
33528     } catch (...) {
33529       {
33530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33531       };
33532     }
33533   }
33534   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33535   return jresult;
33536 }
33537
33538
33539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33540   void * jresult ;
33541   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33542   Dali::RenderTaskList result;
33543
33544   arg1 = (Dali::Stage *)jarg1;
33545   {
33546     try {
33547       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33548     } catch (std::out_of_range& e) {
33549       {
33550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (std::exception& e) {
33553       {
33554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33555       };
33556     } catch (...) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33559       };
33560     }
33561   }
33562   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33563   return jresult;
33564 }
33565
33566
33567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33568   unsigned int jresult ;
33569   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33570   unsigned int result;
33571
33572   arg1 = (Dali::Stage *)jarg1;
33573   {
33574     try {
33575       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33576     } catch (std::out_of_range& e) {
33577       {
33578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33579       };
33580     } catch (std::exception& e) {
33581       {
33582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33583       };
33584     } catch (...) {
33585       {
33586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33587       };
33588     }
33589   }
33590   jresult = result;
33591   return jresult;
33592 }
33593
33594
33595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33596   void * jresult ;
33597   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33598   unsigned int arg2 ;
33599   Dali::Layer result;
33600
33601   arg1 = (Dali::Stage *)jarg1;
33602   arg2 = (unsigned int)jarg2;
33603   {
33604     try {
33605       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33606     } catch (std::out_of_range& e) {
33607       {
33608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33609       };
33610     } catch (std::exception& e) {
33611       {
33612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33613       };
33614     } catch (...) {
33615       {
33616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33617       };
33618     }
33619   }
33620   jresult = new Dali::Layer((const Dali::Layer &)result);
33621   return jresult;
33622 }
33623
33624
33625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33626   void * jresult ;
33627   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33628   Dali::Layer result;
33629
33630   arg1 = (Dali::Stage *)jarg1;
33631   {
33632     try {
33633       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33634     } catch (std::out_of_range& e) {
33635       {
33636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33637       };
33638     } catch (std::exception& e) {
33639       {
33640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33641       };
33642     } catch (...) {
33643       {
33644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33645       };
33646     }
33647   }
33648   jresult = new Dali::Layer((const Dali::Layer &)result);
33649   return jresult;
33650 }
33651
33652
33653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33654   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33655   Dali::Vector4 arg2 ;
33656   Dali::Vector4 *argp2 ;
33657
33658   arg1 = (Dali::Stage *)jarg1;
33659   argp2 = (Dali::Vector4 *)jarg2;
33660   if (!argp2) {
33661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33662     return ;
33663   }
33664   arg2 = *argp2;
33665   {
33666     try {
33667       (arg1)->SetBackgroundColor(arg2);
33668     } catch (std::out_of_range& e) {
33669       {
33670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33671       };
33672     } catch (std::exception& e) {
33673       {
33674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33679       };
33680     }
33681   }
33682 }
33683
33684
33685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33686   void * jresult ;
33687   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33688   Dali::Vector4 result;
33689
33690   arg1 = (Dali::Stage *)jarg1;
33691   {
33692     try {
33693       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33694     } catch (std::out_of_range& e) {
33695       {
33696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33697       };
33698     } catch (std::exception& e) {
33699       {
33700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33701       };
33702     } catch (...) {
33703       {
33704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33705       };
33706     }
33707   }
33708   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33709   return jresult;
33710 }
33711
33712
33713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33714   void * jresult ;
33715   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33716   Dali::Vector2 result;
33717
33718   arg1 = (Dali::Stage *)jarg1;
33719   {
33720     try {
33721       result = ((Dali::Stage const *)arg1)->GetDpi();
33722     } catch (std::out_of_range& e) {
33723       {
33724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33725       };
33726     } catch (std::exception& e) {
33727       {
33728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33733       };
33734     }
33735   }
33736   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33737   return jresult;
33738 }
33739
33740
33741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33742   void * jresult ;
33743   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33744   Dali::ObjectRegistry result;
33745
33746   arg1 = (Dali::Stage *)jarg1;
33747   {
33748     try {
33749       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33750     } catch (std::out_of_range& e) {
33751       {
33752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33753       };
33754     } catch (std::exception& e) {
33755       {
33756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33761       };
33762     }
33763   }
33764   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33765   return jresult;
33766 }
33767
33768
33769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33770   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33771   float arg2 ;
33772
33773   arg1 = (Dali::Stage *)jarg1;
33774   arg2 = (float)jarg2;
33775   {
33776     try {
33777       (arg1)->KeepRendering(arg2);
33778     } catch (std::out_of_range& e) {
33779       {
33780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33781       };
33782     } catch (std::exception& e) {
33783       {
33784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33785       };
33786     } catch (...) {
33787       {
33788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33789       };
33790     }
33791   }
33792 }
33793
33794
33795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33796   void * jresult ;
33797   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33798   Dali::Stage::KeyEventSignalType *result = 0 ;
33799
33800   arg1 = (Dali::Stage *)jarg1;
33801   {
33802     try {
33803       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33804     } catch (std::out_of_range& e) {
33805       {
33806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33807       };
33808     } catch (std::exception& e) {
33809       {
33810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (...) {
33813       {
33814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33815       };
33816     }
33817   }
33818   jresult = (void *)result;
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33824   void * jresult ;
33825   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33826   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33827
33828   arg1 = (Dali::Stage *)jarg1;
33829   {
33830     try {
33831       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33832     } catch (std::out_of_range& e) {
33833       {
33834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33835       };
33836     } catch (std::exception& e) {
33837       {
33838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33839       };
33840     } catch (...) {
33841       {
33842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33843       };
33844     }
33845   }
33846   jresult = (void *)result;
33847   return jresult;
33848 }
33849
33850
33851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33852   void * jresult ;
33853   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33854   Dali::Stage::TouchSignalType *result = 0 ;
33855
33856   arg1 = (Dali::Stage *)jarg1;
33857   {
33858     try {
33859       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33860     } catch (std::out_of_range& e) {
33861       {
33862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33863       };
33864     } catch (std::exception& e) {
33865       {
33866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33867       };
33868     } catch (...) {
33869       {
33870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33871       };
33872     }
33873   }
33874   jresult = (void *)result;
33875   return jresult;
33876 }
33877
33878
33879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33880   void * jresult ;
33881   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33882   Dali::Stage::WheelEventSignalType *result = 0 ;
33883
33884   arg1 = (Dali::Stage *)jarg1;
33885   {
33886     try {
33887       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33888     } catch (std::out_of_range& e) {
33889       {
33890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (std::exception& e) {
33893       {
33894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33895       };
33896     } catch (...) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33899       };
33900     }
33901   }
33902   jresult = (void *)result;
33903   return jresult;
33904 }
33905
33906
33907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33908   void * jresult ;
33909   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33910   Dali::Stage::ContextStatusSignal *result = 0 ;
33911
33912   arg1 = (Dali::Stage *)jarg1;
33913   {
33914     try {
33915       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33916     } catch (std::out_of_range& e) {
33917       {
33918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33919       };
33920     } catch (std::exception& e) {
33921       {
33922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33923       };
33924     } catch (...) {
33925       {
33926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33927       };
33928     }
33929   }
33930   jresult = (void *)result;
33931   return jresult;
33932 }
33933
33934
33935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33936   void * jresult ;
33937   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33938   Dali::Stage::ContextStatusSignal *result = 0 ;
33939
33940   arg1 = (Dali::Stage *)jarg1;
33941   {
33942     try {
33943       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33944     } catch (std::out_of_range& e) {
33945       {
33946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33947       };
33948     } catch (std::exception& e) {
33949       {
33950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33951       };
33952     } catch (...) {
33953       {
33954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33955       };
33956     }
33957   }
33958   jresult = (void *)result;
33959   return jresult;
33960 }
33961
33962
33963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33964   void * jresult ;
33965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33966   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33967
33968   arg1 = (Dali::Stage *)jarg1;
33969   {
33970     try {
33971       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33972     } catch (std::out_of_range& e) {
33973       {
33974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33975       };
33976     } catch (std::exception& e) {
33977       {
33978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33979       };
33980     } catch (...) {
33981       {
33982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33983       };
33984     }
33985   }
33986   jresult = (void *)result;
33987   return jresult;
33988 }
33989
33990
33991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33992   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33993
33994   arg1 = (Dali::RelayoutContainer *)jarg1;
33995   {
33996     try {
33997       delete arg1;
33998     } catch (std::out_of_range& e) {
33999       {
34000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34001       };
34002     } catch (std::exception& e) {
34003       {
34004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34005       };
34006     } catch (...) {
34007       {
34008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34009       };
34010     }
34011   }
34012 }
34013
34014
34015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34016   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34017   Dali::Actor *arg2 = 0 ;
34018   Dali::Vector2 *arg3 = 0 ;
34019
34020   arg1 = (Dali::RelayoutContainer *)jarg1;
34021   arg2 = (Dali::Actor *)jarg2;
34022   if (!arg2) {
34023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34024     return ;
34025   }
34026   arg3 = (Dali::Vector2 *)jarg3;
34027   if (!arg3) {
34028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34029     return ;
34030   }
34031   {
34032     try {
34033       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34034     } catch (std::out_of_range& e) {
34035       {
34036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34037       };
34038     } catch (std::exception& e) {
34039       {
34040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34041       };
34042     } catch (...) {
34043       {
34044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34045       };
34046     }
34047   }
34048 }
34049
34050
34051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34052   void * jresult ;
34053   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34054   Dali::CustomActor result;
34055
34056   arg1 = (Dali::CustomActorImpl *)jarg1;
34057   {
34058     try {
34059       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34060     } catch (std::out_of_range& e) {
34061       {
34062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (std::exception& e) {
34065       {
34066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34067       };
34068     } catch (...) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34071       };
34072     }
34073   }
34074   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34075   return jresult;
34076 }
34077
34078
34079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34080   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34081   int arg2 ;
34082
34083   arg1 = (Dali::CustomActorImpl *)jarg1;
34084   arg2 = (int)jarg2;
34085   {
34086     try {
34087       (arg1)->OnStageConnection(arg2);
34088     } catch (std::out_of_range& e) {
34089       {
34090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34091       };
34092     } catch (std::exception& e) {
34093       {
34094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34095       };
34096     } catch (...) {
34097       {
34098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34099       };
34100     }
34101   }
34102 }
34103
34104
34105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34106   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34107
34108   arg1 = (Dali::CustomActorImpl *)jarg1;
34109   {
34110     try {
34111       (arg1)->OnStageDisconnection();
34112     } catch (std::out_of_range& e) {
34113       {
34114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34115       };
34116     } catch (std::exception& e) {
34117       {
34118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34119       };
34120     } catch (...) {
34121       {
34122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34123       };
34124     }
34125   }
34126 }
34127
34128
34129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34130   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34131   Dali::Actor *arg2 = 0 ;
34132
34133   arg1 = (Dali::CustomActorImpl *)jarg1;
34134   arg2 = (Dali::Actor *)jarg2;
34135   if (!arg2) {
34136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34137     return ;
34138   }
34139   {
34140     try {
34141       (arg1)->OnChildAdd(*arg2);
34142     } catch (std::out_of_range& e) {
34143       {
34144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34145       };
34146     } catch (std::exception& e) {
34147       {
34148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34153       };
34154     }
34155   }
34156 }
34157
34158
34159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34160   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34161   Dali::Actor *arg2 = 0 ;
34162
34163   arg1 = (Dali::CustomActorImpl *)jarg1;
34164   arg2 = (Dali::Actor *)jarg2;
34165   if (!arg2) {
34166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34167     return ;
34168   }
34169   {
34170     try {
34171       (arg1)->OnChildRemove(*arg2);
34172     } catch (std::out_of_range& e) {
34173       {
34174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34175       };
34176     } catch (std::exception& e) {
34177       {
34178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34179       };
34180     } catch (...) {
34181       {
34182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34183       };
34184     }
34185   }
34186 }
34187
34188
34189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34190   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34191   Dali::Property::Index arg2 ;
34192   Dali::Property::Value arg3 ;
34193   Dali::Property::Value *argp3 ;
34194
34195   arg1 = (Dali::CustomActorImpl *)jarg1;
34196   arg2 = (Dali::Property::Index)jarg2;
34197   argp3 = (Dali::Property::Value *)jarg3;
34198   if (!argp3) {
34199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34200     return ;
34201   }
34202   arg3 = *argp3;
34203   {
34204     try {
34205       (arg1)->OnPropertySet(arg2,arg3);
34206     } catch (std::out_of_range& e) {
34207       {
34208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34209       };
34210     } catch (std::exception& e) {
34211       {
34212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34213       };
34214     } catch (...) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34217       };
34218     }
34219   }
34220 }
34221
34222
34223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34224   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34225   Dali::Vector3 *arg2 = 0 ;
34226
34227   arg1 = (Dali::CustomActorImpl *)jarg1;
34228   arg2 = (Dali::Vector3 *)jarg2;
34229   if (!arg2) {
34230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34231     return ;
34232   }
34233   {
34234     try {
34235       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34236     } catch (std::out_of_range& e) {
34237       {
34238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34239       };
34240     } catch (std::exception& e) {
34241       {
34242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34243       };
34244     } catch (...) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34247       };
34248     }
34249   }
34250 }
34251
34252
34253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34254   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34255   Dali::Animation *arg2 = 0 ;
34256   Dali::Vector3 *arg3 = 0 ;
34257
34258   arg1 = (Dali::CustomActorImpl *)jarg1;
34259   arg2 = (Dali::Animation *)jarg2;
34260   if (!arg2) {
34261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34262     return ;
34263   }
34264   arg3 = (Dali::Vector3 *)jarg3;
34265   if (!arg3) {
34266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34267     return ;
34268   }
34269   {
34270     try {
34271       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34272     } catch (std::out_of_range& e) {
34273       {
34274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (std::exception& e) {
34277       {
34278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34283       };
34284     }
34285   }
34286 }
34287
34288
34289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34290   unsigned int jresult ;
34291   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34292   Dali::TouchEvent *arg2 = 0 ;
34293   bool result;
34294
34295   arg1 = (Dali::CustomActorImpl *)jarg1;
34296   arg2 = (Dali::TouchEvent *)jarg2;
34297   if (!arg2) {
34298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34299     return 0;
34300   }
34301   {
34302     try {
34303       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34304     } catch (std::out_of_range& e) {
34305       {
34306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34307       };
34308     } catch (std::exception& e) {
34309       {
34310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34311       };
34312     } catch (...) {
34313       {
34314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34315       };
34316     }
34317   }
34318   jresult = result;
34319   return jresult;
34320 }
34321
34322
34323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34324   unsigned int jresult ;
34325   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34326   Dali::HoverEvent *arg2 = 0 ;
34327   bool result;
34328
34329   arg1 = (Dali::CustomActorImpl *)jarg1;
34330   arg2 = (Dali::HoverEvent *)jarg2;
34331   if (!arg2) {
34332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34333     return 0;
34334   }
34335   {
34336     try {
34337       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34345       };
34346     } catch (...) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34349       };
34350     }
34351   }
34352   jresult = result;
34353   return jresult;
34354 }
34355
34356
34357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34358   unsigned int jresult ;
34359   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34360   Dali::KeyEvent *arg2 = 0 ;
34361   bool result;
34362
34363   arg1 = (Dali::CustomActorImpl *)jarg1;
34364   arg2 = (Dali::KeyEvent *)jarg2;
34365   if (!arg2) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34367     return 0;
34368   }
34369   {
34370     try {
34371       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34379       };
34380     } catch (...) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34383       };
34384     }
34385   }
34386   jresult = result;
34387   return jresult;
34388 }
34389
34390
34391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34392   unsigned int jresult ;
34393   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34394   Dali::WheelEvent *arg2 = 0 ;
34395   bool result;
34396
34397   arg1 = (Dali::CustomActorImpl *)jarg1;
34398   arg2 = (Dali::WheelEvent *)jarg2;
34399   if (!arg2) {
34400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34401     return 0;
34402   }
34403   {
34404     try {
34405       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34406     } catch (std::out_of_range& e) {
34407       {
34408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34409       };
34410     } catch (std::exception& e) {
34411       {
34412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34413       };
34414     } catch (...) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34417       };
34418     }
34419   }
34420   jresult = result;
34421   return jresult;
34422 }
34423
34424
34425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34426   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34427   Dali::Vector2 *arg2 = 0 ;
34428   Dali::RelayoutContainer *arg3 = 0 ;
34429
34430   arg1 = (Dali::CustomActorImpl *)jarg1;
34431   arg2 = (Dali::Vector2 *)jarg2;
34432   if (!arg2) {
34433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34434     return ;
34435   }
34436   arg3 = (Dali::RelayoutContainer *)jarg3;
34437   if (!arg3) {
34438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34439     return ;
34440   }
34441   {
34442     try {
34443       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34444     } catch (std::out_of_range& e) {
34445       {
34446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34447       };
34448     } catch (std::exception& e) {
34449       {
34450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34451       };
34452     } catch (...) {
34453       {
34454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34455       };
34456     }
34457   }
34458 }
34459
34460
34461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34462   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34463   Dali::ResizePolicy::Type arg2 ;
34464   Dali::Dimension::Type arg3 ;
34465
34466   arg1 = (Dali::CustomActorImpl *)jarg1;
34467   arg2 = (Dali::ResizePolicy::Type)jarg2;
34468   arg3 = (Dali::Dimension::Type)jarg3;
34469   {
34470     try {
34471       (arg1)->OnSetResizePolicy(arg2,arg3);
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34479       };
34480     } catch (...) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34483       };
34484     }
34485   }
34486 }
34487
34488
34489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34490   void * jresult ;
34491   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34492   Dali::Vector3 result;
34493
34494   arg1 = (Dali::CustomActorImpl *)jarg1;
34495   {
34496     try {
34497       result = (arg1)->GetNaturalSize();
34498     } catch (std::out_of_range& e) {
34499       {
34500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34501       };
34502     } catch (std::exception& e) {
34503       {
34504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34505       };
34506     } catch (...) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34509       };
34510     }
34511   }
34512   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34513   return jresult;
34514 }
34515
34516
34517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34518   float jresult ;
34519   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34520   Dali::Actor *arg2 = 0 ;
34521   Dali::Dimension::Type arg3 ;
34522   float result;
34523
34524   arg1 = (Dali::CustomActorImpl *)jarg1;
34525   arg2 = (Dali::Actor *)jarg2;
34526   if (!arg2) {
34527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34528     return 0;
34529   }
34530   arg3 = (Dali::Dimension::Type)jarg3;
34531   {
34532     try {
34533       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34534     } catch (std::out_of_range& e) {
34535       {
34536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34537       };
34538     } catch (std::exception& e) {
34539       {
34540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34541       };
34542     } catch (...) {
34543       {
34544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34545       };
34546     }
34547   }
34548   jresult = result;
34549   return jresult;
34550 }
34551
34552
34553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34554   float jresult ;
34555   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34556   float arg2 ;
34557   float result;
34558
34559   arg1 = (Dali::CustomActorImpl *)jarg1;
34560   arg2 = (float)jarg2;
34561   {
34562     try {
34563       result = (float)(arg1)->GetHeightForWidth(arg2);
34564     } catch (std::out_of_range& e) {
34565       {
34566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34567       };
34568     } catch (std::exception& e) {
34569       {
34570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34571       };
34572     } catch (...) {
34573       {
34574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34575       };
34576     }
34577   }
34578   jresult = result;
34579   return jresult;
34580 }
34581
34582
34583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34584   float jresult ;
34585   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34586   float arg2 ;
34587   float result;
34588
34589   arg1 = (Dali::CustomActorImpl *)jarg1;
34590   arg2 = (float)jarg2;
34591   {
34592     try {
34593       result = (float)(arg1)->GetWidthForHeight(arg2);
34594     } catch (std::out_of_range& e) {
34595       {
34596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34597       };
34598     } catch (std::exception& e) {
34599       {
34600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (...) {
34603       {
34604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34605       };
34606     }
34607   }
34608   jresult = result;
34609   return jresult;
34610 }
34611
34612
34613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34614   unsigned int jresult ;
34615   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34616   Dali::Dimension::Type arg2 ;
34617   bool result;
34618
34619   arg1 = (Dali::CustomActorImpl *)jarg1;
34620   arg2 = (Dali::Dimension::Type)jarg2;
34621   {
34622     try {
34623       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34624     } catch (std::out_of_range& e) {
34625       {
34626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34627       };
34628     } catch (std::exception& e) {
34629       {
34630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34631       };
34632     } catch (...) {
34633       {
34634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34635       };
34636     }
34637   }
34638   jresult = result;
34639   return jresult;
34640 }
34641
34642
34643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34644   unsigned int jresult ;
34645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34646   bool result;
34647
34648   arg1 = (Dali::CustomActorImpl *)jarg1;
34649   {
34650     try {
34651       result = (bool)(arg1)->RelayoutDependentOnChildren();
34652     } catch (std::out_of_range& e) {
34653       {
34654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34655       };
34656     } catch (std::exception& e) {
34657       {
34658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34659       };
34660     } catch (...) {
34661       {
34662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34663       };
34664     }
34665   }
34666   jresult = result;
34667   return jresult;
34668 }
34669
34670
34671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34672   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34673   Dali::Dimension::Type arg2 ;
34674
34675   arg1 = (Dali::CustomActorImpl *)jarg1;
34676   arg2 = (Dali::Dimension::Type)jarg2;
34677   {
34678     try {
34679       (arg1)->OnCalculateRelayoutSize(arg2);
34680     } catch (std::out_of_range& e) {
34681       {
34682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34683       };
34684     } catch (std::exception& e) {
34685       {
34686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34687       };
34688     } catch (...) {
34689       {
34690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34691       };
34692     }
34693   }
34694 }
34695
34696
34697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34698   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34699   float arg2 ;
34700   Dali::Dimension::Type arg3 ;
34701
34702   arg1 = (Dali::CustomActorImpl *)jarg1;
34703   arg2 = (float)jarg2;
34704   arg3 = (Dali::Dimension::Type)jarg3;
34705   {
34706     try {
34707       (arg1)->OnLayoutNegotiated(arg2,arg3);
34708     } catch (std::out_of_range& e) {
34709       {
34710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34711       };
34712     } catch (std::exception& e) {
34713       {
34714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (...) {
34717       {
34718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34719       };
34720     }
34721   }
34722 }
34723
34724
34725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34726   unsigned int jresult ;
34727   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34728   bool result;
34729
34730   arg1 = (Dali::CustomActorImpl *)jarg1;
34731   {
34732     try {
34733       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34734     } catch (std::out_of_range& e) {
34735       {
34736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34737       };
34738     } catch (std::exception& e) {
34739       {
34740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34741       };
34742     } catch (...) {
34743       {
34744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34745       };
34746     }
34747   }
34748   jresult = result;
34749   return jresult;
34750 }
34751
34752
34753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34754   unsigned int jresult ;
34755   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34756   bool result;
34757
34758   arg1 = (Dali::CustomActorImpl *)jarg1;
34759   {
34760     try {
34761       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34769       };
34770     } catch (...) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34773       };
34774     }
34775   }
34776   jresult = result;
34777   return jresult;
34778 }
34779
34780
34781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34782   unsigned int jresult ;
34783   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34784   bool result;
34785
34786   arg1 = (Dali::CustomActorImpl *)jarg1;
34787   {
34788     try {
34789       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34790     } catch (std::out_of_range& e) {
34791       {
34792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34793       };
34794     } catch (std::exception& e) {
34795       {
34796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34797       };
34798     } catch (...) {
34799       {
34800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34801       };
34802     }
34803   }
34804   jresult = result;
34805   return jresult;
34806 }
34807
34808
34809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34810   unsigned int jresult ;
34811   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34812   bool result;
34813
34814   arg1 = (Dali::CustomActorImpl *)jarg1;
34815   {
34816     try {
34817       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34818     } catch (std::out_of_range& e) {
34819       {
34820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34821       };
34822     } catch (std::exception& e) {
34823       {
34824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34825       };
34826     } catch (...) {
34827       {
34828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34829       };
34830     }
34831   }
34832   jresult = result;
34833   return jresult;
34834 }
34835
34836
34837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34838   void * jresult ;
34839   Dali::CustomActor *result = 0 ;
34840
34841   {
34842     try {
34843       result = (Dali::CustomActor *)new Dali::CustomActor();
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34855       };
34856     }
34857   }
34858   jresult = (void *)result;
34859   return jresult;
34860 }
34861
34862
34863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34864   void * jresult ;
34865   Dali::BaseHandle arg1 ;
34866   Dali::BaseHandle *argp1 ;
34867   Dali::CustomActor result;
34868
34869   argp1 = (Dali::BaseHandle *)jarg1;
34870   if (!argp1) {
34871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34872     return 0;
34873   }
34874   arg1 = *argp1;
34875   {
34876     try {
34877       result = Dali::CustomActor::DownCast(arg1);
34878     } catch (std::out_of_range& e) {
34879       {
34880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34881       };
34882     } catch (std::exception& e) {
34883       {
34884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34885       };
34886     } catch (...) {
34887       {
34888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34889       };
34890     }
34891   }
34892   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34893   return jresult;
34894 }
34895
34896
34897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34898   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34899
34900   arg1 = (Dali::CustomActor *)jarg1;
34901   {
34902     try {
34903       delete arg1;
34904     } catch (std::out_of_range& e) {
34905       {
34906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34907       };
34908     } catch (std::exception& e) {
34909       {
34910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34911       };
34912     } catch (...) {
34913       {
34914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34915       };
34916     }
34917   }
34918 }
34919
34920
34921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34922   void * jresult ;
34923   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34924   Dali::CustomActorImpl *result = 0 ;
34925
34926   arg1 = (Dali::CustomActor *)jarg1;
34927   {
34928     try {
34929       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34930     } catch (std::out_of_range& e) {
34931       {
34932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34933       };
34934     } catch (std::exception& e) {
34935       {
34936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34937       };
34938     } catch (...) {
34939       {
34940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34941       };
34942     }
34943   }
34944   jresult = (void *)result;
34945   return jresult;
34946 }
34947
34948
34949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34950   void * jresult ;
34951   Dali::CustomActorImpl *arg1 = 0 ;
34952   Dali::CustomActor *result = 0 ;
34953
34954   arg1 = (Dali::CustomActorImpl *)jarg1;
34955   if (!arg1) {
34956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34957     return 0;
34958   }
34959   {
34960     try {
34961       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (...) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34973       };
34974     }
34975   }
34976   jresult = (void *)result;
34977   return jresult;
34978 }
34979
34980
34981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34982   void * jresult ;
34983   Dali::CustomActor *arg1 = 0 ;
34984   Dali::CustomActor *result = 0 ;
34985
34986   arg1 = (Dali::CustomActor *)jarg1;
34987   if (!arg1) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34989     return 0;
34990   }
34991   {
34992     try {
34993       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34994     } catch (std::out_of_range& e) {
34995       {
34996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34997       };
34998     } catch (std::exception& e) {
34999       {
35000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35001       };
35002     } catch (...) {
35003       {
35004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35005       };
35006     }
35007   }
35008   jresult = (void *)result;
35009   return jresult;
35010 }
35011
35012
35013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35014   void * jresult ;
35015   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35016   Dali::CustomActor *arg2 = 0 ;
35017   Dali::CustomActor *result = 0 ;
35018
35019   arg1 = (Dali::CustomActor *)jarg1;
35020   arg2 = (Dali::CustomActor *)jarg2;
35021   if (!arg2) {
35022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35023     return 0;
35024   }
35025   {
35026     try {
35027       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35028     } catch (std::out_of_range& e) {
35029       {
35030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35031       };
35032     } catch (std::exception& e) {
35033       {
35034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35035       };
35036     } catch (...) {
35037       {
35038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35039       };
35040     }
35041   }
35042   jresult = (void *)result;
35043   return jresult;
35044 }
35045
35046
35047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35048   int jresult ;
35049   int result;
35050
35051   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35052   jresult = (int)result;
35053   return jresult;
35054 }
35055
35056
35057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35058   int jresult ;
35059   int result;
35060
35061   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35062   jresult = (int)result;
35063   return jresult;
35064 }
35065
35066
35067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35068   int jresult ;
35069   int result;
35070
35071   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35072   jresult = (int)result;
35073   return jresult;
35074 }
35075
35076
35077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35078   int jresult ;
35079   int result;
35080
35081   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35082   jresult = (int)result;
35083   return jresult;
35084 }
35085
35086
35087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35088   int jresult ;
35089   int result;
35090
35091   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35092   jresult = (int)result;
35093   return jresult;
35094 }
35095
35096
35097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35098   int jresult ;
35099   int result;
35100
35101   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35102   jresult = (int)result;
35103   return jresult;
35104 }
35105
35106
35107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35108   int jresult ;
35109   int result;
35110
35111   result = (int)Dali::PanGestureDetector::Property::PANNING;
35112   jresult = (int)result;
35113   return jresult;
35114 }
35115
35116
35117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35118   void * jresult ;
35119   Dali::PanGestureDetector::Property *result = 0 ;
35120
35121   {
35122     try {
35123       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35124     } catch (std::out_of_range& e) {
35125       {
35126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35127       };
35128     } catch (std::exception& e) {
35129       {
35130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35131       };
35132     } catch (...) {
35133       {
35134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35135       };
35136     }
35137   }
35138   jresult = (void *)result;
35139   return jresult;
35140 }
35141
35142
35143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35144   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35145
35146   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35147   {
35148     try {
35149       delete arg1;
35150     } catch (std::out_of_range& e) {
35151       {
35152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35153       };
35154     } catch (std::exception& e) {
35155       {
35156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35157       };
35158     } catch (...) {
35159       {
35160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35161       };
35162     }
35163   }
35164 }
35165
35166
35167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35168   void * jresult ;
35169   Dali::Radian *result = 0 ;
35170
35171   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35172   jresult = (void *)result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35178   void * jresult ;
35179   Dali::Radian *result = 0 ;
35180
35181   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35182   jresult = (void *)result;
35183   return jresult;
35184 }
35185
35186
35187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35188   void * jresult ;
35189   Dali::Radian *result = 0 ;
35190
35191   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35192   jresult = (void *)result;
35193   return jresult;
35194 }
35195
35196
35197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35198   void * jresult ;
35199   Dali::Radian *result = 0 ;
35200
35201   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35202   jresult = (void *)result;
35203   return jresult;
35204 }
35205
35206
35207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35208   void * jresult ;
35209   Dali::Radian *result = 0 ;
35210
35211   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35212   jresult = (void *)result;
35213   return jresult;
35214 }
35215
35216
35217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35218   void * jresult ;
35219   Dali::Radian *result = 0 ;
35220
35221   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35222   jresult = (void *)result;
35223   return jresult;
35224 }
35225
35226
35227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35228   void * jresult ;
35229   Dali::Radian *result = 0 ;
35230
35231   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35232   jresult = (void *)result;
35233   return jresult;
35234 }
35235
35236
35237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35238   void * jresult ;
35239   Dali::PanGestureDetector *result = 0 ;
35240
35241   {
35242     try {
35243       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35244     } catch (std::out_of_range& e) {
35245       {
35246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35247       };
35248     } catch (std::exception& e) {
35249       {
35250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35251       };
35252     } catch (...) {
35253       {
35254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35255       };
35256     }
35257   }
35258   jresult = (void *)result;
35259   return jresult;
35260 }
35261
35262
35263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35264   void * jresult ;
35265   Dali::PanGestureDetector result;
35266
35267   {
35268     try {
35269       result = Dali::PanGestureDetector::New();
35270     } catch (std::out_of_range& e) {
35271       {
35272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35273       };
35274     } catch (std::exception& e) {
35275       {
35276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35277       };
35278     } catch (...) {
35279       {
35280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35281       };
35282     }
35283   }
35284   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35285   return jresult;
35286 }
35287
35288
35289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35290   void * jresult ;
35291   Dali::BaseHandle arg1 ;
35292   Dali::BaseHandle *argp1 ;
35293   Dali::PanGestureDetector result;
35294
35295   argp1 = (Dali::BaseHandle *)jarg1;
35296   if (!argp1) {
35297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35298     return 0;
35299   }
35300   arg1 = *argp1;
35301   {
35302     try {
35303       result = Dali::PanGestureDetector::DownCast(arg1);
35304     } catch (std::out_of_range& e) {
35305       {
35306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35307       };
35308     } catch (std::exception& e) {
35309       {
35310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35311       };
35312     } catch (...) {
35313       {
35314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35315       };
35316     }
35317   }
35318   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35319   return jresult;
35320 }
35321
35322
35323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35324   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35325
35326   arg1 = (Dali::PanGestureDetector *)jarg1;
35327   {
35328     try {
35329       delete arg1;
35330     } catch (std::out_of_range& e) {
35331       {
35332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35333       };
35334     } catch (std::exception& e) {
35335       {
35336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35337       };
35338     } catch (...) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35341       };
35342     }
35343   }
35344 }
35345
35346
35347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35348   void * jresult ;
35349   Dali::PanGestureDetector *arg1 = 0 ;
35350   Dali::PanGestureDetector *result = 0 ;
35351
35352   arg1 = (Dali::PanGestureDetector *)jarg1;
35353   if (!arg1) {
35354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35355     return 0;
35356   }
35357   {
35358     try {
35359       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35360     } catch (std::out_of_range& e) {
35361       {
35362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35363       };
35364     } catch (std::exception& e) {
35365       {
35366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35367       };
35368     } catch (...) {
35369       {
35370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35371       };
35372     }
35373   }
35374   jresult = (void *)result;
35375   return jresult;
35376 }
35377
35378
35379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35380   void * jresult ;
35381   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35382   Dali::PanGestureDetector *arg2 = 0 ;
35383   Dali::PanGestureDetector *result = 0 ;
35384
35385   arg1 = (Dali::PanGestureDetector *)jarg1;
35386   arg2 = (Dali::PanGestureDetector *)jarg2;
35387   if (!arg2) {
35388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35389     return 0;
35390   }
35391   {
35392     try {
35393       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35394     } catch (std::out_of_range& e) {
35395       {
35396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35397       };
35398     } catch (std::exception& e) {
35399       {
35400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35401       };
35402     } catch (...) {
35403       {
35404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35405       };
35406     }
35407   }
35408   jresult = (void *)result;
35409   return jresult;
35410 }
35411
35412
35413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35414   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35415   unsigned int arg2 ;
35416
35417   arg1 = (Dali::PanGestureDetector *)jarg1;
35418   arg2 = (unsigned int)jarg2;
35419   {
35420     try {
35421       (arg1)->SetMinimumTouchesRequired(arg2);
35422     } catch (std::out_of_range& e) {
35423       {
35424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35425       };
35426     } catch (std::exception& e) {
35427       {
35428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35429       };
35430     } catch (...) {
35431       {
35432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35433       };
35434     }
35435   }
35436 }
35437
35438
35439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35440   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35441   unsigned int arg2 ;
35442
35443   arg1 = (Dali::PanGestureDetector *)jarg1;
35444   arg2 = (unsigned int)jarg2;
35445   {
35446     try {
35447       (arg1)->SetMaximumTouchesRequired(arg2);
35448     } catch (std::out_of_range& e) {
35449       {
35450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35451       };
35452     } catch (std::exception& e) {
35453       {
35454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35455       };
35456     } catch (...) {
35457       {
35458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35459       };
35460     }
35461   }
35462 }
35463
35464
35465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35466   unsigned int jresult ;
35467   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35468   unsigned int result;
35469
35470   arg1 = (Dali::PanGestureDetector *)jarg1;
35471   {
35472     try {
35473       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35474     } catch (std::out_of_range& e) {
35475       {
35476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (std::exception& e) {
35479       {
35480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35481       };
35482     } catch (...) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35485       };
35486     }
35487   }
35488   jresult = result;
35489   return jresult;
35490 }
35491
35492
35493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35494   unsigned int jresult ;
35495   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35496   unsigned int result;
35497
35498   arg1 = (Dali::PanGestureDetector *)jarg1;
35499   {
35500     try {
35501       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35502     } catch (std::out_of_range& e) {
35503       {
35504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35505       };
35506     } catch (std::exception& e) {
35507       {
35508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35509       };
35510     } catch (...) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35513       };
35514     }
35515   }
35516   jresult = result;
35517   return jresult;
35518 }
35519
35520
35521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35522   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35523   Dali::Radian arg2 ;
35524   Dali::Radian arg3 ;
35525   Dali::Radian *argp2 ;
35526   Dali::Radian *argp3 ;
35527
35528   arg1 = (Dali::PanGestureDetector *)jarg1;
35529   argp2 = (Dali::Radian *)jarg2;
35530   if (!argp2) {
35531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35532     return ;
35533   }
35534   arg2 = *argp2;
35535   argp3 = (Dali::Radian *)jarg3;
35536   if (!argp3) {
35537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35538     return ;
35539   }
35540   arg3 = *argp3;
35541   {
35542     try {
35543       (arg1)->AddAngle(arg2,arg3);
35544     } catch (std::out_of_range& e) {
35545       {
35546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35547       };
35548     } catch (std::exception& e) {
35549       {
35550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35551       };
35552     } catch (...) {
35553       {
35554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35555       };
35556     }
35557   }
35558 }
35559
35560
35561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35562   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35563   Dali::Radian arg2 ;
35564   Dali::Radian *argp2 ;
35565
35566   arg1 = (Dali::PanGestureDetector *)jarg1;
35567   argp2 = (Dali::Radian *)jarg2;
35568   if (!argp2) {
35569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35570     return ;
35571   }
35572   arg2 = *argp2;
35573   {
35574     try {
35575       (arg1)->AddAngle(arg2);
35576     } catch (std::out_of_range& e) {
35577       {
35578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35579       };
35580     } catch (std::exception& e) {
35581       {
35582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35583       };
35584     } catch (...) {
35585       {
35586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35587       };
35588     }
35589   }
35590 }
35591
35592
35593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35594   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35595   Dali::Radian arg2 ;
35596   Dali::Radian arg3 ;
35597   Dali::Radian *argp2 ;
35598   Dali::Radian *argp3 ;
35599
35600   arg1 = (Dali::PanGestureDetector *)jarg1;
35601   argp2 = (Dali::Radian *)jarg2;
35602   if (!argp2) {
35603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35604     return ;
35605   }
35606   arg2 = *argp2;
35607   argp3 = (Dali::Radian *)jarg3;
35608   if (!argp3) {
35609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35610     return ;
35611   }
35612   arg3 = *argp3;
35613   {
35614     try {
35615       (arg1)->AddDirection(arg2,arg3);
35616     } catch (std::out_of_range& e) {
35617       {
35618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35619       };
35620     } catch (std::exception& e) {
35621       {
35622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35623       };
35624     } catch (...) {
35625       {
35626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35627       };
35628     }
35629   }
35630 }
35631
35632
35633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35634   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35635   Dali::Radian arg2 ;
35636   Dali::Radian *argp2 ;
35637
35638   arg1 = (Dali::PanGestureDetector *)jarg1;
35639   argp2 = (Dali::Radian *)jarg2;
35640   if (!argp2) {
35641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35642     return ;
35643   }
35644   arg2 = *argp2;
35645   {
35646     try {
35647       (arg1)->AddDirection(arg2);
35648     } catch (std::out_of_range& e) {
35649       {
35650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35651       };
35652     } catch (std::exception& e) {
35653       {
35654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35655       };
35656     } catch (...) {
35657       {
35658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35659       };
35660     }
35661   }
35662 }
35663
35664
35665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35666   unsigned long jresult ;
35667   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35668   size_t result;
35669
35670   arg1 = (Dali::PanGestureDetector *)jarg1;
35671   {
35672     try {
35673       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35674     } catch (std::out_of_range& e) {
35675       {
35676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35677       };
35678     } catch (std::exception& e) {
35679       {
35680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35681       };
35682     } catch (...) {
35683       {
35684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35685       };
35686     }
35687   }
35688   jresult = (unsigned long)result;
35689   return jresult;
35690 }
35691
35692
35693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35694   void * jresult ;
35695   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35696   size_t arg2 ;
35697   Dali::PanGestureDetector::AngleThresholdPair result;
35698
35699   arg1 = (Dali::PanGestureDetector *)jarg1;
35700   arg2 = (size_t)jarg2;
35701   {
35702     try {
35703       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35704     } catch (std::out_of_range& e) {
35705       {
35706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35707       };
35708     } catch (std::exception& e) {
35709       {
35710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35711       };
35712     } catch (...) {
35713       {
35714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35715       };
35716     }
35717   }
35718   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35719   return jresult;
35720 }
35721
35722
35723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35724   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35725
35726   arg1 = (Dali::PanGestureDetector *)jarg1;
35727   {
35728     try {
35729       (arg1)->ClearAngles();
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (...) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35741       };
35742     }
35743   }
35744 }
35745
35746
35747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35748   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35749   Dali::Radian arg2 ;
35750   Dali::Radian *argp2 ;
35751
35752   arg1 = (Dali::PanGestureDetector *)jarg1;
35753   argp2 = (Dali::Radian *)jarg2;
35754   if (!argp2) {
35755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35756     return ;
35757   }
35758   arg2 = *argp2;
35759   {
35760     try {
35761       (arg1)->RemoveAngle(arg2);
35762     } catch (std::out_of_range& e) {
35763       {
35764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35765       };
35766     } catch (std::exception& e) {
35767       {
35768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35769       };
35770     } catch (...) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35773       };
35774     }
35775   }
35776 }
35777
35778
35779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35780   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35781   Dali::Radian arg2 ;
35782   Dali::Radian *argp2 ;
35783
35784   arg1 = (Dali::PanGestureDetector *)jarg1;
35785   argp2 = (Dali::Radian *)jarg2;
35786   if (!argp2) {
35787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35788     return ;
35789   }
35790   arg2 = *argp2;
35791   {
35792     try {
35793       (arg1)->RemoveDirection(arg2);
35794     } catch (std::out_of_range& e) {
35795       {
35796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35797       };
35798     } catch (std::exception& e) {
35799       {
35800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35801       };
35802     } catch (...) {
35803       {
35804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35805       };
35806     }
35807   }
35808 }
35809
35810
35811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35812   void * jresult ;
35813   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35814   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35815
35816   arg1 = (Dali::PanGestureDetector *)jarg1;
35817   {
35818     try {
35819       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35820     } catch (std::out_of_range& e) {
35821       {
35822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35823       };
35824     } catch (std::exception& e) {
35825       {
35826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35827       };
35828     } catch (...) {
35829       {
35830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35831       };
35832     }
35833   }
35834   jresult = (void *)result;
35835   return jresult;
35836 }
35837
35838
35839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35840   Dali::PanGesture *arg1 = 0 ;
35841
35842   arg1 = (Dali::PanGesture *)jarg1;
35843   if (!arg1) {
35844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35845     return ;
35846   }
35847   {
35848     try {
35849       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35850     } catch (std::out_of_range& e) {
35851       {
35852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35853       };
35854     } catch (std::exception& e) {
35855       {
35856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (...) {
35859       {
35860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35861       };
35862     }
35863   }
35864 }
35865
35866
35867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35868   void * jresult ;
35869   Dali::PanGesture *result = 0 ;
35870
35871   {
35872     try {
35873       result = (Dali::PanGesture *)new Dali::PanGesture();
35874     } catch (std::out_of_range& e) {
35875       {
35876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35877       };
35878     } catch (std::exception& e) {
35879       {
35880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35881       };
35882     } catch (...) {
35883       {
35884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35885       };
35886     }
35887   }
35888   jresult = (void *)result;
35889   return jresult;
35890 }
35891
35892
35893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35894   void * jresult ;
35895   Dali::Gesture::State arg1 ;
35896   Dali::PanGesture *result = 0 ;
35897
35898   arg1 = (Dali::Gesture::State)jarg1;
35899   {
35900     try {
35901       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35902     } catch (std::out_of_range& e) {
35903       {
35904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35905       };
35906     } catch (std::exception& e) {
35907       {
35908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35913       };
35914     }
35915   }
35916   jresult = (void *)result;
35917   return jresult;
35918 }
35919
35920
35921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35922   void * jresult ;
35923   Dali::PanGesture *arg1 = 0 ;
35924   Dali::PanGesture *result = 0 ;
35925
35926   arg1 = (Dali::PanGesture *)jarg1;
35927   if (!arg1) {
35928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35929     return 0;
35930   }
35931   {
35932     try {
35933       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35934     } catch (std::out_of_range& e) {
35935       {
35936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35937       };
35938     } catch (std::exception& e) {
35939       {
35940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35941       };
35942     } catch (...) {
35943       {
35944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35945       };
35946     }
35947   }
35948   jresult = (void *)result;
35949   return jresult;
35950 }
35951
35952
35953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35954   void * jresult ;
35955   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35956   Dali::PanGesture *arg2 = 0 ;
35957   Dali::PanGesture *result = 0 ;
35958
35959   arg1 = (Dali::PanGesture *)jarg1;
35960   arg2 = (Dali::PanGesture *)jarg2;
35961   if (!arg2) {
35962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35963     return 0;
35964   }
35965   {
35966     try {
35967       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35968     } catch (std::out_of_range& e) {
35969       {
35970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35971       };
35972     } catch (std::exception& e) {
35973       {
35974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35975       };
35976     } catch (...) {
35977       {
35978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35979       };
35980     }
35981   }
35982   jresult = (void *)result;
35983   return jresult;
35984 }
35985
35986
35987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35988   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35989
35990   arg1 = (Dali::PanGesture *)jarg1;
35991   {
35992     try {
35993       delete arg1;
35994     } catch (std::out_of_range& e) {
35995       {
35996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35997       };
35998     } catch (std::exception& e) {
35999       {
36000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36005       };
36006     }
36007   }
36008 }
36009
36010
36011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36012   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36013   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36014
36015   arg1 = (Dali::PanGesture *)jarg1;
36016   arg2 = (Dali::Vector2 *)jarg2;
36017   if (arg1) (arg1)->velocity = *arg2;
36018 }
36019
36020
36021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36022   void * jresult ;
36023   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36024   Dali::Vector2 *result = 0 ;
36025
36026   arg1 = (Dali::PanGesture *)jarg1;
36027   result = (Dali::Vector2 *)& ((arg1)->velocity);
36028   jresult = (void *)result;
36029   return jresult;
36030 }
36031
36032
36033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36034   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36035   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36036
36037   arg1 = (Dali::PanGesture *)jarg1;
36038   arg2 = (Dali::Vector2 *)jarg2;
36039   if (arg1) (arg1)->displacement = *arg2;
36040 }
36041
36042
36043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36044   void * jresult ;
36045   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36046   Dali::Vector2 *result = 0 ;
36047
36048   arg1 = (Dali::PanGesture *)jarg1;
36049   result = (Dali::Vector2 *)& ((arg1)->displacement);
36050   jresult = (void *)result;
36051   return jresult;
36052 }
36053
36054
36055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36056   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36057   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36058
36059   arg1 = (Dali::PanGesture *)jarg1;
36060   arg2 = (Dali::Vector2 *)jarg2;
36061   if (arg1) (arg1)->position = *arg2;
36062 }
36063
36064
36065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36066   void * jresult ;
36067   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36068   Dali::Vector2 *result = 0 ;
36069
36070   arg1 = (Dali::PanGesture *)jarg1;
36071   result = (Dali::Vector2 *)& ((arg1)->position);
36072   jresult = (void *)result;
36073   return jresult;
36074 }
36075
36076
36077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36078   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36079   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36080
36081   arg1 = (Dali::PanGesture *)jarg1;
36082   arg2 = (Dali::Vector2 *)jarg2;
36083   if (arg1) (arg1)->screenVelocity = *arg2;
36084 }
36085
36086
36087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36088   void * jresult ;
36089   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36090   Dali::Vector2 *result = 0 ;
36091
36092   arg1 = (Dali::PanGesture *)jarg1;
36093   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36094   jresult = (void *)result;
36095   return jresult;
36096 }
36097
36098
36099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36100   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36101   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36102
36103   arg1 = (Dali::PanGesture *)jarg1;
36104   arg2 = (Dali::Vector2 *)jarg2;
36105   if (arg1) (arg1)->screenDisplacement = *arg2;
36106 }
36107
36108
36109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36110   void * jresult ;
36111   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36112   Dali::Vector2 *result = 0 ;
36113
36114   arg1 = (Dali::PanGesture *)jarg1;
36115   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36116   jresult = (void *)result;
36117   return jresult;
36118 }
36119
36120
36121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36122   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36123   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36124
36125   arg1 = (Dali::PanGesture *)jarg1;
36126   arg2 = (Dali::Vector2 *)jarg2;
36127   if (arg1) (arg1)->screenPosition = *arg2;
36128 }
36129
36130
36131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36132   void * jresult ;
36133   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36134   Dali::Vector2 *result = 0 ;
36135
36136   arg1 = (Dali::PanGesture *)jarg1;
36137   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36138   jresult = (void *)result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36144   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36145   unsigned int arg2 ;
36146
36147   arg1 = (Dali::PanGesture *)jarg1;
36148   arg2 = (unsigned int)jarg2;
36149   if (arg1) (arg1)->numberOfTouches = arg2;
36150 }
36151
36152
36153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36154   unsigned int jresult ;
36155   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36156   unsigned int result;
36157
36158   arg1 = (Dali::PanGesture *)jarg1;
36159   result = (unsigned int) ((arg1)->numberOfTouches);
36160   jresult = result;
36161   return jresult;
36162 }
36163
36164
36165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36166   float jresult ;
36167   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36168   float result;
36169
36170   arg1 = (Dali::PanGesture *)jarg1;
36171   {
36172     try {
36173       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36174     } catch (std::out_of_range& e) {
36175       {
36176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36177       };
36178     } catch (std::exception& e) {
36179       {
36180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36181       };
36182     } catch (...) {
36183       {
36184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36185       };
36186     }
36187   }
36188   jresult = result;
36189   return jresult;
36190 }
36191
36192
36193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36194   float jresult ;
36195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36196   float result;
36197
36198   arg1 = (Dali::PanGesture *)jarg1;
36199   {
36200     try {
36201       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36202     } catch (std::out_of_range& e) {
36203       {
36204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36205       };
36206     } catch (std::exception& e) {
36207       {
36208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36209       };
36210     } catch (...) {
36211       {
36212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36213       };
36214     }
36215   }
36216   jresult = result;
36217   return jresult;
36218 }
36219
36220
36221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36222   float jresult ;
36223   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36224   float result;
36225
36226   arg1 = (Dali::PanGesture *)jarg1;
36227   {
36228     try {
36229       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36230     } catch (std::out_of_range& e) {
36231       {
36232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36233       };
36234     } catch (std::exception& e) {
36235       {
36236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36237       };
36238     } catch (...) {
36239       {
36240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36241       };
36242     }
36243   }
36244   jresult = result;
36245   return jresult;
36246 }
36247
36248
36249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36250   float jresult ;
36251   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36252   float result;
36253
36254   arg1 = (Dali::PanGesture *)jarg1;
36255   {
36256     try {
36257       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36258     } catch (std::out_of_range& e) {
36259       {
36260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36261       };
36262     } catch (std::exception& e) {
36263       {
36264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36265       };
36266     } catch (...) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36269       };
36270     }
36271   }
36272   jresult = result;
36273   return jresult;
36274 }
36275
36276
36277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36278   void * jresult ;
36279   Dali::PinchGestureDetector *result = 0 ;
36280
36281   {
36282     try {
36283       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36284     } catch (std::out_of_range& e) {
36285       {
36286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36287       };
36288     } catch (std::exception& e) {
36289       {
36290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (...) {
36293       {
36294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36295       };
36296     }
36297   }
36298   jresult = (void *)result;
36299   return jresult;
36300 }
36301
36302
36303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36304   void * jresult ;
36305   Dali::PinchGestureDetector result;
36306
36307   {
36308     try {
36309       result = Dali::PinchGestureDetector::New();
36310     } catch (std::out_of_range& e) {
36311       {
36312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36313       };
36314     } catch (std::exception& e) {
36315       {
36316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36317       };
36318     } catch (...) {
36319       {
36320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36321       };
36322     }
36323   }
36324   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36325   return jresult;
36326 }
36327
36328
36329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36330   void * jresult ;
36331   Dali::BaseHandle arg1 ;
36332   Dali::BaseHandle *argp1 ;
36333   Dali::PinchGestureDetector result;
36334
36335   argp1 = (Dali::BaseHandle *)jarg1;
36336   if (!argp1) {
36337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36338     return 0;
36339   }
36340   arg1 = *argp1;
36341   {
36342     try {
36343       result = Dali::PinchGestureDetector::DownCast(arg1);
36344     } catch (std::out_of_range& e) {
36345       {
36346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36347       };
36348     } catch (std::exception& e) {
36349       {
36350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36351       };
36352     } catch (...) {
36353       {
36354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36355       };
36356     }
36357   }
36358   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36359   return jresult;
36360 }
36361
36362
36363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36364   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36365
36366   arg1 = (Dali::PinchGestureDetector *)jarg1;
36367   {
36368     try {
36369       delete arg1;
36370     } catch (std::out_of_range& e) {
36371       {
36372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36373       };
36374     } catch (std::exception& e) {
36375       {
36376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36377       };
36378     } catch (...) {
36379       {
36380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36381       };
36382     }
36383   }
36384 }
36385
36386
36387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36388   void * jresult ;
36389   Dali::PinchGestureDetector *arg1 = 0 ;
36390   Dali::PinchGestureDetector *result = 0 ;
36391
36392   arg1 = (Dali::PinchGestureDetector *)jarg1;
36393   if (!arg1) {
36394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36395     return 0;
36396   }
36397   {
36398     try {
36399       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36400     } catch (std::out_of_range& e) {
36401       {
36402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36403       };
36404     } catch (std::exception& e) {
36405       {
36406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36407       };
36408     } catch (...) {
36409       {
36410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36411       };
36412     }
36413   }
36414   jresult = (void *)result;
36415   return jresult;
36416 }
36417
36418
36419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36420   void * jresult ;
36421   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36422   Dali::PinchGestureDetector *arg2 = 0 ;
36423   Dali::PinchGestureDetector *result = 0 ;
36424
36425   arg1 = (Dali::PinchGestureDetector *)jarg1;
36426   arg2 = (Dali::PinchGestureDetector *)jarg2;
36427   if (!arg2) {
36428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36429     return 0;
36430   }
36431   {
36432     try {
36433       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36434     } catch (std::out_of_range& e) {
36435       {
36436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36437       };
36438     } catch (std::exception& e) {
36439       {
36440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36441       };
36442     } catch (...) {
36443       {
36444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36445       };
36446     }
36447   }
36448   jresult = (void *)result;
36449   return jresult;
36450 }
36451
36452
36453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36454   void * jresult ;
36455   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36456   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36457
36458   arg1 = (Dali::PinchGestureDetector *)jarg1;
36459   {
36460     try {
36461       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36462     } catch (std::out_of_range& e) {
36463       {
36464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36465       };
36466     } catch (std::exception& e) {
36467       {
36468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (...) {
36471       {
36472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36473       };
36474     }
36475   }
36476   jresult = (void *)result;
36477   return jresult;
36478 }
36479
36480
36481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36482   void * jresult ;
36483   Dali::Gesture::State arg1 ;
36484   Dali::PinchGesture *result = 0 ;
36485
36486   arg1 = (Dali::Gesture::State)jarg1;
36487   {
36488     try {
36489       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36490     } catch (std::out_of_range& e) {
36491       {
36492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36493       };
36494     } catch (std::exception& e) {
36495       {
36496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (...) {
36499       {
36500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36501       };
36502     }
36503   }
36504   jresult = (void *)result;
36505   return jresult;
36506 }
36507
36508
36509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36510   void * jresult ;
36511   Dali::PinchGesture *arg1 = 0 ;
36512   Dali::PinchGesture *result = 0 ;
36513
36514   arg1 = (Dali::PinchGesture *)jarg1;
36515   if (!arg1) {
36516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36517     return 0;
36518   }
36519   {
36520     try {
36521       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36522     } catch (std::out_of_range& e) {
36523       {
36524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36525       };
36526     } catch (std::exception& e) {
36527       {
36528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (...) {
36531       {
36532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36533       };
36534     }
36535   }
36536   jresult = (void *)result;
36537   return jresult;
36538 }
36539
36540
36541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36542   void * jresult ;
36543   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36544   Dali::PinchGesture *arg2 = 0 ;
36545   Dali::PinchGesture *result = 0 ;
36546
36547   arg1 = (Dali::PinchGesture *)jarg1;
36548   arg2 = (Dali::PinchGesture *)jarg2;
36549   if (!arg2) {
36550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36551     return 0;
36552   }
36553   {
36554     try {
36555       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36556     } catch (std::out_of_range& e) {
36557       {
36558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (std::exception& e) {
36561       {
36562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (...) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36567       };
36568     }
36569   }
36570   jresult = (void *)result;
36571   return jresult;
36572 }
36573
36574
36575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36576   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36577
36578   arg1 = (Dali::PinchGesture *)jarg1;
36579   {
36580     try {
36581       delete arg1;
36582     } catch (std::out_of_range& e) {
36583       {
36584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36585       };
36586     } catch (std::exception& e) {
36587       {
36588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36589       };
36590     } catch (...) {
36591       {
36592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36593       };
36594     }
36595   }
36596 }
36597
36598
36599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36600   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36601   float arg2 ;
36602
36603   arg1 = (Dali::PinchGesture *)jarg1;
36604   arg2 = (float)jarg2;
36605   if (arg1) (arg1)->scale = arg2;
36606 }
36607
36608
36609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36610   float jresult ;
36611   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36612   float result;
36613
36614   arg1 = (Dali::PinchGesture *)jarg1;
36615   result = (float) ((arg1)->scale);
36616   jresult = result;
36617   return jresult;
36618 }
36619
36620
36621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36622   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36623   float arg2 ;
36624
36625   arg1 = (Dali::PinchGesture *)jarg1;
36626   arg2 = (float)jarg2;
36627   if (arg1) (arg1)->speed = arg2;
36628 }
36629
36630
36631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36632   float jresult ;
36633   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36634   float result;
36635
36636   arg1 = (Dali::PinchGesture *)jarg1;
36637   result = (float) ((arg1)->speed);
36638   jresult = result;
36639   return jresult;
36640 }
36641
36642
36643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36644   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36645   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36646
36647   arg1 = (Dali::PinchGesture *)jarg1;
36648   arg2 = (Dali::Vector2 *)jarg2;
36649   if (arg1) (arg1)->screenCenterPoint = *arg2;
36650 }
36651
36652
36653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36654   void * jresult ;
36655   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36656   Dali::Vector2 *result = 0 ;
36657
36658   arg1 = (Dali::PinchGesture *)jarg1;
36659   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36660   jresult = (void *)result;
36661   return jresult;
36662 }
36663
36664
36665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36666   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36667   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36668
36669   arg1 = (Dali::PinchGesture *)jarg1;
36670   arg2 = (Dali::Vector2 *)jarg2;
36671   if (arg1) (arg1)->localCenterPoint = *arg2;
36672 }
36673
36674
36675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36676   void * jresult ;
36677   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36678   Dali::Vector2 *result = 0 ;
36679
36680   arg1 = (Dali::PinchGesture *)jarg1;
36681   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36682   jresult = (void *)result;
36683   return jresult;
36684 }
36685
36686
36687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36688   void * jresult ;
36689   Dali::TapGestureDetector *result = 0 ;
36690
36691   {
36692     try {
36693       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36694     } catch (std::out_of_range& e) {
36695       {
36696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36697       };
36698     } catch (std::exception& e) {
36699       {
36700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36701       };
36702     } catch (...) {
36703       {
36704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36705       };
36706     }
36707   }
36708   jresult = (void *)result;
36709   return jresult;
36710 }
36711
36712
36713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36714   void * jresult ;
36715   Dali::TapGestureDetector result;
36716
36717   {
36718     try {
36719       result = Dali::TapGestureDetector::New();
36720     } catch (std::out_of_range& e) {
36721       {
36722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36723       };
36724     } catch (std::exception& e) {
36725       {
36726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36727       };
36728     } catch (...) {
36729       {
36730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36731       };
36732     }
36733   }
36734   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36735   return jresult;
36736 }
36737
36738
36739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36740   void * jresult ;
36741   unsigned int arg1 ;
36742   Dali::TapGestureDetector result;
36743
36744   arg1 = (unsigned int)jarg1;
36745   {
36746     try {
36747       result = Dali::TapGestureDetector::New(arg1);
36748     } catch (std::out_of_range& e) {
36749       {
36750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36751       };
36752     } catch (std::exception& e) {
36753       {
36754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36755       };
36756     } catch (...) {
36757       {
36758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36759       };
36760     }
36761   }
36762   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36763   return jresult;
36764 }
36765
36766
36767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36768   void * jresult ;
36769   Dali::BaseHandle arg1 ;
36770   Dali::BaseHandle *argp1 ;
36771   Dali::TapGestureDetector result;
36772
36773   argp1 = (Dali::BaseHandle *)jarg1;
36774   if (!argp1) {
36775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36776     return 0;
36777   }
36778   arg1 = *argp1;
36779   {
36780     try {
36781       result = Dali::TapGestureDetector::DownCast(arg1);
36782     } catch (std::out_of_range& e) {
36783       {
36784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36785       };
36786     } catch (std::exception& e) {
36787       {
36788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36789       };
36790     } catch (...) {
36791       {
36792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36793       };
36794     }
36795   }
36796   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36797   return jresult;
36798 }
36799
36800
36801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36802   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36803
36804   arg1 = (Dali::TapGestureDetector *)jarg1;
36805   {
36806     try {
36807       delete arg1;
36808     } catch (std::out_of_range& e) {
36809       {
36810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36811       };
36812     } catch (std::exception& e) {
36813       {
36814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36815       };
36816     } catch (...) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36819       };
36820     }
36821   }
36822 }
36823
36824
36825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36826   void * jresult ;
36827   Dali::TapGestureDetector *arg1 = 0 ;
36828   Dali::TapGestureDetector *result = 0 ;
36829
36830   arg1 = (Dali::TapGestureDetector *)jarg1;
36831   if (!arg1) {
36832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36833     return 0;
36834   }
36835   {
36836     try {
36837       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36838     } catch (std::out_of_range& e) {
36839       {
36840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36841       };
36842     } catch (std::exception& e) {
36843       {
36844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36845       };
36846     } catch (...) {
36847       {
36848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36849       };
36850     }
36851   }
36852   jresult = (void *)result;
36853   return jresult;
36854 }
36855
36856
36857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36858   void * jresult ;
36859   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36860   Dali::TapGestureDetector *arg2 = 0 ;
36861   Dali::TapGestureDetector *result = 0 ;
36862
36863   arg1 = (Dali::TapGestureDetector *)jarg1;
36864   arg2 = (Dali::TapGestureDetector *)jarg2;
36865   if (!arg2) {
36866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36867     return 0;
36868   }
36869   {
36870     try {
36871       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36872     } catch (std::out_of_range& e) {
36873       {
36874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (std::exception& e) {
36877       {
36878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (...) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36883       };
36884     }
36885   }
36886   jresult = (void *)result;
36887   return jresult;
36888 }
36889
36890
36891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36892   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36893   unsigned int arg2 ;
36894
36895   arg1 = (Dali::TapGestureDetector *)jarg1;
36896   arg2 = (unsigned int)jarg2;
36897   {
36898     try {
36899       (arg1)->SetMinimumTapsRequired(arg2);
36900     } catch (std::out_of_range& e) {
36901       {
36902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36903       };
36904     } catch (std::exception& e) {
36905       {
36906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36907       };
36908     } catch (...) {
36909       {
36910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36911       };
36912     }
36913   }
36914 }
36915
36916
36917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36918   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36919   unsigned int arg2 ;
36920
36921   arg1 = (Dali::TapGestureDetector *)jarg1;
36922   arg2 = (unsigned int)jarg2;
36923   {
36924     try {
36925       (arg1)->SetMaximumTapsRequired(arg2);
36926     } catch (std::out_of_range& e) {
36927       {
36928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36929       };
36930     } catch (std::exception& e) {
36931       {
36932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36933       };
36934     } catch (...) {
36935       {
36936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36937       };
36938     }
36939   }
36940 }
36941
36942
36943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36944   unsigned int jresult ;
36945   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36946   unsigned int result;
36947
36948   arg1 = (Dali::TapGestureDetector *)jarg1;
36949   {
36950     try {
36951       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36952     } catch (std::out_of_range& e) {
36953       {
36954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36955       };
36956     } catch (std::exception& e) {
36957       {
36958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36959       };
36960     } catch (...) {
36961       {
36962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36963       };
36964     }
36965   }
36966   jresult = result;
36967   return jresult;
36968 }
36969
36970
36971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36972   unsigned int jresult ;
36973   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36974   unsigned int result;
36975
36976   arg1 = (Dali::TapGestureDetector *)jarg1;
36977   {
36978     try {
36979       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36980     } catch (std::out_of_range& e) {
36981       {
36982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (std::exception& e) {
36985       {
36986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36987       };
36988     } catch (...) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36991       };
36992     }
36993   }
36994   jresult = result;
36995   return jresult;
36996 }
36997
36998
36999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37000   void * jresult ;
37001   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37002   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37003
37004   arg1 = (Dali::TapGestureDetector *)jarg1;
37005   {
37006     try {
37007       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37015       };
37016     } catch (...) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37019       };
37020     }
37021   }
37022   jresult = (void *)result;
37023   return jresult;
37024 }
37025
37026
37027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37028   void * jresult ;
37029   Dali::TapGesture *result = 0 ;
37030
37031   {
37032     try {
37033       result = (Dali::TapGesture *)new Dali::TapGesture();
37034     } catch (std::out_of_range& e) {
37035       {
37036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37037       };
37038     } catch (std::exception& e) {
37039       {
37040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (...) {
37043       {
37044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37045       };
37046     }
37047   }
37048   jresult = (void *)result;
37049   return jresult;
37050 }
37051
37052
37053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37054   void * jresult ;
37055   Dali::TapGesture *arg1 = 0 ;
37056   Dali::TapGesture *result = 0 ;
37057
37058   arg1 = (Dali::TapGesture *)jarg1;
37059   if (!arg1) {
37060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37061     return 0;
37062   }
37063   {
37064     try {
37065       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37066     } catch (std::out_of_range& e) {
37067       {
37068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (std::exception& e) {
37071       {
37072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37073       };
37074     } catch (...) {
37075       {
37076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37077       };
37078     }
37079   }
37080   jresult = (void *)result;
37081   return jresult;
37082 }
37083
37084
37085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37086   void * jresult ;
37087   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37088   Dali::TapGesture *arg2 = 0 ;
37089   Dali::TapGesture *result = 0 ;
37090
37091   arg1 = (Dali::TapGesture *)jarg1;
37092   arg2 = (Dali::TapGesture *)jarg2;
37093   if (!arg2) {
37094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37095     return 0;
37096   }
37097   {
37098     try {
37099       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37100     } catch (std::out_of_range& e) {
37101       {
37102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37103       };
37104     } catch (std::exception& e) {
37105       {
37106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37107       };
37108     } catch (...) {
37109       {
37110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37111       };
37112     }
37113   }
37114   jresult = (void *)result;
37115   return jresult;
37116 }
37117
37118
37119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37120   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37121
37122   arg1 = (Dali::TapGesture *)jarg1;
37123   {
37124     try {
37125       delete arg1;
37126     } catch (std::out_of_range& e) {
37127       {
37128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37129       };
37130     } catch (std::exception& e) {
37131       {
37132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37133       };
37134     } catch (...) {
37135       {
37136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37137       };
37138     }
37139   }
37140 }
37141
37142
37143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37144   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37145   unsigned int arg2 ;
37146
37147   arg1 = (Dali::TapGesture *)jarg1;
37148   arg2 = (unsigned int)jarg2;
37149   if (arg1) (arg1)->numberOfTaps = arg2;
37150 }
37151
37152
37153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37154   unsigned int jresult ;
37155   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37156   unsigned int result;
37157
37158   arg1 = (Dali::TapGesture *)jarg1;
37159   result = (unsigned int) ((arg1)->numberOfTaps);
37160   jresult = result;
37161   return jresult;
37162 }
37163
37164
37165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37166   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37167   unsigned int arg2 ;
37168
37169   arg1 = (Dali::TapGesture *)jarg1;
37170   arg2 = (unsigned int)jarg2;
37171   if (arg1) (arg1)->numberOfTouches = arg2;
37172 }
37173
37174
37175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37176   unsigned int jresult ;
37177   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37178   unsigned int result;
37179
37180   arg1 = (Dali::TapGesture *)jarg1;
37181   result = (unsigned int) ((arg1)->numberOfTouches);
37182   jresult = result;
37183   return jresult;
37184 }
37185
37186
37187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37188   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37189   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37190
37191   arg1 = (Dali::TapGesture *)jarg1;
37192   arg2 = (Dali::Vector2 *)jarg2;
37193   if (arg1) (arg1)->screenPoint = *arg2;
37194 }
37195
37196
37197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37198   void * jresult ;
37199   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37200   Dali::Vector2 *result = 0 ;
37201
37202   arg1 = (Dali::TapGesture *)jarg1;
37203   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37204   jresult = (void *)result;
37205   return jresult;
37206 }
37207
37208
37209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37210   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37211   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37212
37213   arg1 = (Dali::TapGesture *)jarg1;
37214   arg2 = (Dali::Vector2 *)jarg2;
37215   if (arg1) (arg1)->localPoint = *arg2;
37216 }
37217
37218
37219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37220   void * jresult ;
37221   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37222   Dali::Vector2 *result = 0 ;
37223
37224   arg1 = (Dali::TapGesture *)jarg1;
37225   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37226   jresult = (void *)result;
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37232   void * jresult ;
37233   Dali::AlphaFunction *result = 0 ;
37234
37235   {
37236     try {
37237       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37238     } catch (std::out_of_range& e) {
37239       {
37240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37241       };
37242     } catch (std::exception& e) {
37243       {
37244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37245       };
37246     } catch (...) {
37247       {
37248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37249       };
37250     }
37251   }
37252   jresult = (void *)result;
37253   return jresult;
37254 }
37255
37256
37257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37258   void * jresult ;
37259   Dali::AlphaFunction::BuiltinFunction arg1 ;
37260   Dali::AlphaFunction *result = 0 ;
37261
37262   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37263   {
37264     try {
37265       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37266     } catch (std::out_of_range& e) {
37267       {
37268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37269       };
37270     } catch (std::exception& e) {
37271       {
37272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37273       };
37274     } catch (...) {
37275       {
37276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37277       };
37278     }
37279   }
37280   jresult = (void *)result;
37281   return jresult;
37282 }
37283
37284
37285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37286   void * jresult ;
37287   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37288   Dali::AlphaFunction *result = 0 ;
37289
37290   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37291   {
37292     try {
37293       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37294     } catch (std::out_of_range& e) {
37295       {
37296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (std::exception& e) {
37299       {
37300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37314   void * jresult ;
37315   Dali::Vector2 *arg1 = 0 ;
37316   Dali::Vector2 *arg2 = 0 ;
37317   Dali::AlphaFunction *result = 0 ;
37318
37319   arg1 = (Dali::Vector2 *)jarg1;
37320   if (!arg1) {
37321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37322     return 0;
37323   }
37324   arg2 = (Dali::Vector2 *)jarg2;
37325   if (!arg2) {
37326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37327     return 0;
37328   }
37329   {
37330     try {
37331       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37332     } catch (std::out_of_range& e) {
37333       {
37334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37335       };
37336     } catch (std::exception& e) {
37337       {
37338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37339       };
37340     } catch (...) {
37341       {
37342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37343       };
37344     }
37345   }
37346   jresult = (void *)result;
37347   return jresult;
37348 }
37349
37350
37351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37352   void * jresult ;
37353   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37354   Dali::Vector4 result;
37355
37356   arg1 = (Dali::AlphaFunction *)jarg1;
37357   {
37358     try {
37359       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37360     } catch (std::out_of_range& e) {
37361       {
37362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37363       };
37364     } catch (std::exception& e) {
37365       {
37366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37367       };
37368     } catch (...) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37371       };
37372     }
37373   }
37374   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37375   return jresult;
37376 }
37377
37378
37379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37380   void * jresult ;
37381   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37382   Dali::AlphaFunctionPrototype result;
37383
37384   arg1 = (Dali::AlphaFunction *)jarg1;
37385   {
37386     try {
37387       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37388     } catch (std::out_of_range& e) {
37389       {
37390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37391       };
37392     } catch (std::exception& e) {
37393       {
37394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37395       };
37396     } catch (...) {
37397       {
37398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37399       };
37400     }
37401   }
37402   jresult = (void *)result;
37403   return jresult;
37404 }
37405
37406
37407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37408   int jresult ;
37409   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37410   Dali::AlphaFunction::BuiltinFunction result;
37411
37412   arg1 = (Dali::AlphaFunction *)jarg1;
37413   {
37414     try {
37415       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37416     } catch (std::out_of_range& e) {
37417       {
37418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37419       };
37420     } catch (std::exception& e) {
37421       {
37422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37423       };
37424     } catch (...) {
37425       {
37426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37427       };
37428     }
37429   }
37430   jresult = (int)result;
37431   return jresult;
37432 }
37433
37434
37435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37436   int jresult ;
37437   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37438   Dali::AlphaFunction::Mode result;
37439
37440   arg1 = (Dali::AlphaFunction *)jarg1;
37441   {
37442     try {
37443       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37444     } catch (std::out_of_range& e) {
37445       {
37446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37447       };
37448     } catch (std::exception& e) {
37449       {
37450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (...) {
37453       {
37454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37455       };
37456     }
37457   }
37458   jresult = (int)result;
37459   return jresult;
37460 }
37461
37462
37463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37464   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37465
37466   arg1 = (Dali::AlphaFunction *)jarg1;
37467   {
37468     try {
37469       delete arg1;
37470     } catch (std::out_of_range& e) {
37471       {
37472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37473       };
37474     } catch (std::exception& e) {
37475       {
37476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37477       };
37478     } catch (...) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37481       };
37482     }
37483   }
37484 }
37485
37486
37487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37488   void * jresult ;
37489   Dali::KeyFrames result;
37490
37491   {
37492     try {
37493       result = Dali::KeyFrames::New();
37494     } catch (std::out_of_range& e) {
37495       {
37496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37497       };
37498     } catch (std::exception& e) {
37499       {
37500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37501       };
37502     } catch (...) {
37503       {
37504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37505       };
37506     }
37507   }
37508   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37509   return jresult;
37510 }
37511
37512
37513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37514   void * jresult ;
37515   Dali::BaseHandle arg1 ;
37516   Dali::BaseHandle *argp1 ;
37517   Dali::KeyFrames result;
37518
37519   argp1 = (Dali::BaseHandle *)jarg1;
37520   if (!argp1) {
37521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37522     return 0;
37523   }
37524   arg1 = *argp1;
37525   {
37526     try {
37527       result = Dali::KeyFrames::DownCast(arg1);
37528     } catch (std::out_of_range& e) {
37529       {
37530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37531       };
37532     } catch (std::exception& e) {
37533       {
37534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37535       };
37536     } catch (...) {
37537       {
37538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37539       };
37540     }
37541   }
37542   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37543   return jresult;
37544 }
37545
37546
37547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37548   void * jresult ;
37549   Dali::KeyFrames *result = 0 ;
37550
37551   {
37552     try {
37553       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37554     } catch (std::out_of_range& e) {
37555       {
37556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37557       };
37558     } catch (std::exception& e) {
37559       {
37560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37561       };
37562     } catch (...) {
37563       {
37564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37565       };
37566     }
37567   }
37568   jresult = (void *)result;
37569   return jresult;
37570 }
37571
37572
37573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37574   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37575
37576   arg1 = (Dali::KeyFrames *)jarg1;
37577   {
37578     try {
37579       delete arg1;
37580     } catch (std::out_of_range& e) {
37581       {
37582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37583       };
37584     } catch (std::exception& e) {
37585       {
37586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37587       };
37588     } catch (...) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37591       };
37592     }
37593   }
37594 }
37595
37596
37597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37598   void * jresult ;
37599   Dali::KeyFrames *arg1 = 0 ;
37600   Dali::KeyFrames *result = 0 ;
37601
37602   arg1 = (Dali::KeyFrames *)jarg1;
37603   if (!arg1) {
37604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37605     return 0;
37606   }
37607   {
37608     try {
37609       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37610     } catch (std::out_of_range& e) {
37611       {
37612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37613       };
37614     } catch (std::exception& e) {
37615       {
37616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37617       };
37618     } catch (...) {
37619       {
37620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37621       };
37622     }
37623   }
37624   jresult = (void *)result;
37625   return jresult;
37626 }
37627
37628
37629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37630   void * jresult ;
37631   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37632   Dali::KeyFrames *arg2 = 0 ;
37633   Dali::KeyFrames *result = 0 ;
37634
37635   arg1 = (Dali::KeyFrames *)jarg1;
37636   arg2 = (Dali::KeyFrames *)jarg2;
37637   if (!arg2) {
37638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37639     return 0;
37640   }
37641   {
37642     try {
37643       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37655       };
37656     }
37657   }
37658   jresult = (void *)result;
37659   return jresult;
37660 }
37661
37662
37663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37664   int jresult ;
37665   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37666   Dali::Property::Type result;
37667
37668   arg1 = (Dali::KeyFrames *)jarg1;
37669   {
37670     try {
37671       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37672     } catch (std::out_of_range& e) {
37673       {
37674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37675       };
37676     } catch (std::exception& e) {
37677       {
37678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37679       };
37680     } catch (...) {
37681       {
37682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37683       };
37684     }
37685   }
37686   jresult = (int)result;
37687   return jresult;
37688 }
37689
37690
37691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37692   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37693   float arg2 ;
37694   Dali::Property::Value arg3 ;
37695   Dali::Property::Value *argp3 ;
37696
37697   arg1 = (Dali::KeyFrames *)jarg1;
37698   arg2 = (float)jarg2;
37699   argp3 = (Dali::Property::Value *)jarg3;
37700   if (!argp3) {
37701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37702     return ;
37703   }
37704   arg3 = *argp3;
37705   {
37706     try {
37707       (arg1)->Add(arg2,arg3);
37708     } catch (std::out_of_range& e) {
37709       {
37710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37711       };
37712     } catch (std::exception& e) {
37713       {
37714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37715       };
37716     } catch (...) {
37717       {
37718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37719       };
37720     }
37721   }
37722 }
37723
37724
37725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37726   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37727   float arg2 ;
37728   Dali::Property::Value arg3 ;
37729   Dali::AlphaFunction arg4 ;
37730   Dali::Property::Value *argp3 ;
37731   Dali::AlphaFunction *argp4 ;
37732
37733   arg1 = (Dali::KeyFrames *)jarg1;
37734   arg2 = (float)jarg2;
37735   argp3 = (Dali::Property::Value *)jarg3;
37736   if (!argp3) {
37737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37738     return ;
37739   }
37740   arg3 = *argp3;
37741   argp4 = (Dali::AlphaFunction *)jarg4;
37742   if (!argp4) {
37743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37744     return ;
37745   }
37746   arg4 = *argp4;
37747   {
37748     try {
37749       (arg1)->Add(arg2,arg3,arg4);
37750     } catch (std::out_of_range& e) {
37751       {
37752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37753       };
37754     } catch (std::exception& e) {
37755       {
37756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37757       };
37758     } catch (...) {
37759       {
37760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37761       };
37762     }
37763   }
37764 }
37765
37766
37767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37768   int jresult ;
37769   int result;
37770
37771   result = (int)Dali::Path::Property::POINTS;
37772   jresult = (int)result;
37773   return jresult;
37774 }
37775
37776
37777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37778   int jresult ;
37779   int result;
37780
37781   result = (int)Dali::Path::Property::CONTROL_POINTS;
37782   jresult = (int)result;
37783   return jresult;
37784 }
37785
37786
37787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37788   void * jresult ;
37789   Dali::Path::Property *result = 0 ;
37790
37791   {
37792     try {
37793       result = (Dali::Path::Property *)new Dali::Path::Property();
37794     } catch (std::out_of_range& e) {
37795       {
37796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37797       };
37798     } catch (std::exception& e) {
37799       {
37800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37801       };
37802     } catch (...) {
37803       {
37804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37805       };
37806     }
37807   }
37808   jresult = (void *)result;
37809   return jresult;
37810 }
37811
37812
37813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37814   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37815
37816   arg1 = (Dali::Path::Property *)jarg1;
37817   {
37818     try {
37819       delete arg1;
37820     } catch (std::out_of_range& e) {
37821       {
37822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37823       };
37824     } catch (std::exception& e) {
37825       {
37826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37827       };
37828     } catch (...) {
37829       {
37830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37831       };
37832     }
37833   }
37834 }
37835
37836
37837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37838   void * jresult ;
37839   Dali::Path result;
37840
37841   {
37842     try {
37843       result = Dali::Path::New();
37844     } catch (std::out_of_range& e) {
37845       {
37846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37847       };
37848     } catch (std::exception& e) {
37849       {
37850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37851       };
37852     } catch (...) {
37853       {
37854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37855       };
37856     }
37857   }
37858   jresult = new Dali::Path((const Dali::Path &)result);
37859   return jresult;
37860 }
37861
37862
37863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37864   void * jresult ;
37865   Dali::BaseHandle arg1 ;
37866   Dali::BaseHandle *argp1 ;
37867   Dali::Path result;
37868
37869   argp1 = (Dali::BaseHandle *)jarg1;
37870   if (!argp1) {
37871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37872     return 0;
37873   }
37874   arg1 = *argp1;
37875   {
37876     try {
37877       result = Dali::Path::DownCast(arg1);
37878     } catch (std::out_of_range& e) {
37879       {
37880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37881       };
37882     } catch (std::exception& e) {
37883       {
37884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37885       };
37886     } catch (...) {
37887       {
37888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37889       };
37890     }
37891   }
37892   jresult = new Dali::Path((const Dali::Path &)result);
37893   return jresult;
37894 }
37895
37896
37897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37898   void * jresult ;
37899   Dali::Path *result = 0 ;
37900
37901   {
37902     try {
37903       result = (Dali::Path *)new Dali::Path();
37904     } catch (std::out_of_range& e) {
37905       {
37906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37907       };
37908     } catch (std::exception& e) {
37909       {
37910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37911       };
37912     } catch (...) {
37913       {
37914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37915       };
37916     }
37917   }
37918   jresult = (void *)result;
37919   return jresult;
37920 }
37921
37922
37923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37924   Dali::Path *arg1 = (Dali::Path *) 0 ;
37925
37926   arg1 = (Dali::Path *)jarg1;
37927   {
37928     try {
37929       delete arg1;
37930     } catch (std::out_of_range& e) {
37931       {
37932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37933       };
37934     } catch (std::exception& e) {
37935       {
37936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37937       };
37938     } catch (...) {
37939       {
37940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37941       };
37942     }
37943   }
37944 }
37945
37946
37947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37948   void * jresult ;
37949   Dali::Path *arg1 = 0 ;
37950   Dali::Path *result = 0 ;
37951
37952   arg1 = (Dali::Path *)jarg1;
37953   if (!arg1) {
37954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37955     return 0;
37956   }
37957   {
37958     try {
37959       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37967       };
37968     } catch (...) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37971       };
37972     }
37973   }
37974   jresult = (void *)result;
37975   return jresult;
37976 }
37977
37978
37979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37980   void * jresult ;
37981   Dali::Path *arg1 = (Dali::Path *) 0 ;
37982   Dali::Path *arg2 = 0 ;
37983   Dali::Path *result = 0 ;
37984
37985   arg1 = (Dali::Path *)jarg1;
37986   arg2 = (Dali::Path *)jarg2;
37987   if (!arg2) {
37988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37989     return 0;
37990   }
37991   {
37992     try {
37993       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37994     } catch (std::out_of_range& e) {
37995       {
37996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37997       };
37998     } catch (std::exception& e) {
37999       {
38000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38001       };
38002     } catch (...) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38005       };
38006     }
38007   }
38008   jresult = (void *)result;
38009   return jresult;
38010 }
38011
38012
38013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38014   Dali::Path *arg1 = (Dali::Path *) 0 ;
38015   Dali::Vector3 *arg2 = 0 ;
38016
38017   arg1 = (Dali::Path *)jarg1;
38018   arg2 = (Dali::Vector3 *)jarg2;
38019   if (!arg2) {
38020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38021     return ;
38022   }
38023   {
38024     try {
38025       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38026     } catch (std::out_of_range& e) {
38027       {
38028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38029       };
38030     } catch (std::exception& e) {
38031       {
38032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (...) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38037       };
38038     }
38039   }
38040 }
38041
38042
38043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38044   Dali::Path *arg1 = (Dali::Path *) 0 ;
38045   Dali::Vector3 *arg2 = 0 ;
38046
38047   arg1 = (Dali::Path *)jarg1;
38048   arg2 = (Dali::Vector3 *)jarg2;
38049   if (!arg2) {
38050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38051     return ;
38052   }
38053   {
38054     try {
38055       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38056     } catch (std::out_of_range& e) {
38057       {
38058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (std::exception& e) {
38061       {
38062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38063       };
38064     } catch (...) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38067       };
38068     }
38069   }
38070 }
38071
38072
38073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38074   Dali::Path *arg1 = (Dali::Path *) 0 ;
38075   float arg2 ;
38076
38077   arg1 = (Dali::Path *)jarg1;
38078   arg2 = (float)jarg2;
38079   {
38080     try {
38081       (arg1)->GenerateControlPoints(arg2);
38082     } catch (std::out_of_range& e) {
38083       {
38084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38085       };
38086     } catch (std::exception& e) {
38087       {
38088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38089       };
38090     } catch (...) {
38091       {
38092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38093       };
38094     }
38095   }
38096 }
38097
38098
38099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38100   Dali::Path *arg1 = (Dali::Path *) 0 ;
38101   float arg2 ;
38102   Dali::Vector3 *arg3 = 0 ;
38103   Dali::Vector3 *arg4 = 0 ;
38104
38105   arg1 = (Dali::Path *)jarg1;
38106   arg2 = (float)jarg2;
38107   arg3 = (Dali::Vector3 *)jarg3;
38108   if (!arg3) {
38109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38110     return ;
38111   }
38112   arg4 = (Dali::Vector3 *)jarg4;
38113   if (!arg4) {
38114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38115     return ;
38116   }
38117   {
38118     try {
38119       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38120     } catch (std::out_of_range& e) {
38121       {
38122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38123       };
38124     } catch (std::exception& e) {
38125       {
38126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38127       };
38128     } catch (...) {
38129       {
38130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38131       };
38132     }
38133   }
38134 }
38135
38136
38137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38138   void * jresult ;
38139   Dali::Path *arg1 = (Dali::Path *) 0 ;
38140   size_t arg2 ;
38141   Dali::Vector3 *result = 0 ;
38142
38143   arg1 = (Dali::Path *)jarg1;
38144   arg2 = (size_t)jarg2;
38145   {
38146     try {
38147       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38148     } catch (std::out_of_range& e) {
38149       {
38150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38151       };
38152     } catch (std::exception& e) {
38153       {
38154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38155       };
38156     } catch (...) {
38157       {
38158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38159       };
38160     }
38161   }
38162   jresult = (void *)result;
38163   return jresult;
38164 }
38165
38166
38167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38168   void * jresult ;
38169   Dali::Path *arg1 = (Dali::Path *) 0 ;
38170   size_t arg2 ;
38171   Dali::Vector3 *result = 0 ;
38172
38173   arg1 = (Dali::Path *)jarg1;
38174   arg2 = (size_t)jarg2;
38175   {
38176     try {
38177       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38178     } catch (std::out_of_range& e) {
38179       {
38180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38181       };
38182     } catch (std::exception& e) {
38183       {
38184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38185       };
38186     } catch (...) {
38187       {
38188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38189       };
38190     }
38191   }
38192   jresult = (void *)result;
38193   return jresult;
38194 }
38195
38196
38197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38198   unsigned long jresult ;
38199   Dali::Path *arg1 = (Dali::Path *) 0 ;
38200   size_t result;
38201
38202   arg1 = (Dali::Path *)jarg1;
38203   {
38204     try {
38205       result = ((Dali::Path const *)arg1)->GetPointCount();
38206     } catch (std::out_of_range& e) {
38207       {
38208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38209       };
38210     } catch (std::exception& e) {
38211       {
38212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38213       };
38214     } catch (...) {
38215       {
38216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38217       };
38218     }
38219   }
38220   jresult = (unsigned long)result;
38221   return jresult;
38222 }
38223
38224
38225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38226   void * jresult ;
38227   float arg1 ;
38228   Dali::TimePeriod *result = 0 ;
38229
38230   arg1 = (float)jarg1;
38231   {
38232     try {
38233       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38234     } catch (std::out_of_range& e) {
38235       {
38236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (std::exception& e) {
38239       {
38240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38241       };
38242     } catch (...) {
38243       {
38244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38245       };
38246     }
38247   }
38248   jresult = (void *)result;
38249   return jresult;
38250 }
38251
38252
38253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38254   void * jresult ;
38255   float arg1 ;
38256   float arg2 ;
38257   Dali::TimePeriod *result = 0 ;
38258
38259   arg1 = (float)jarg1;
38260   arg2 = (float)jarg2;
38261   {
38262     try {
38263       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38264     } catch (std::out_of_range& e) {
38265       {
38266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38267       };
38268     } catch (std::exception& e) {
38269       {
38270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38271       };
38272     } catch (...) {
38273       {
38274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38275       };
38276     }
38277   }
38278   jresult = (void *)result;
38279   return jresult;
38280 }
38281
38282
38283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38284   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38285
38286   arg1 = (Dali::TimePeriod *)jarg1;
38287   {
38288     try {
38289       delete arg1;
38290     } catch (std::out_of_range& e) {
38291       {
38292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38293       };
38294     } catch (std::exception& e) {
38295       {
38296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38297       };
38298     } catch (...) {
38299       {
38300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38301       };
38302     }
38303   }
38304 }
38305
38306
38307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38308   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38309   float arg2 ;
38310
38311   arg1 = (Dali::TimePeriod *)jarg1;
38312   arg2 = (float)jarg2;
38313   if (arg1) (arg1)->delaySeconds = arg2;
38314 }
38315
38316
38317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38318   float jresult ;
38319   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38320   float result;
38321
38322   arg1 = (Dali::TimePeriod *)jarg1;
38323   result = (float) ((arg1)->delaySeconds);
38324   jresult = result;
38325   return jresult;
38326 }
38327
38328
38329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38330   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38331   float arg2 ;
38332
38333   arg1 = (Dali::TimePeriod *)jarg1;
38334   arg2 = (float)jarg2;
38335   if (arg1) (arg1)->durationSeconds = arg2;
38336 }
38337
38338
38339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38340   float jresult ;
38341   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38342   float result;
38343
38344   arg1 = (Dali::TimePeriod *)jarg1;
38345   result = (float) ((arg1)->durationSeconds);
38346   jresult = result;
38347   return jresult;
38348 }
38349
38350
38351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38352   void * jresult ;
38353   Dali::Animation *result = 0 ;
38354
38355   {
38356     try {
38357       result = (Dali::Animation *)new Dali::Animation();
38358     } catch (std::out_of_range& e) {
38359       {
38360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38361       };
38362     } catch (std::exception& e) {
38363       {
38364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38365       };
38366     } catch (...) {
38367       {
38368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38369       };
38370     }
38371   }
38372   jresult = (void *)result;
38373   return jresult;
38374 }
38375
38376
38377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38378   void * jresult ;
38379   float arg1 ;
38380   Dali::Animation result;
38381
38382   arg1 = (float)jarg1;
38383   {
38384     try {
38385       result = Dali::Animation::New(arg1);
38386     } catch (std::out_of_range& e) {
38387       {
38388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38389       };
38390     } catch (std::exception& e) {
38391       {
38392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38393       };
38394     } catch (...) {
38395       {
38396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38397       };
38398     }
38399   }
38400   jresult = new Dali::Animation((const Dali::Animation &)result);
38401   return jresult;
38402 }
38403
38404
38405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38406   void * jresult ;
38407   Dali::BaseHandle arg1 ;
38408   Dali::BaseHandle *argp1 ;
38409   Dali::Animation result;
38410
38411   argp1 = (Dali::BaseHandle *)jarg1;
38412   if (!argp1) {
38413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38414     return 0;
38415   }
38416   arg1 = *argp1;
38417   {
38418     try {
38419       result = Dali::Animation::DownCast(arg1);
38420     } catch (std::out_of_range& e) {
38421       {
38422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38423       };
38424     } catch (std::exception& e) {
38425       {
38426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38427       };
38428     } catch (...) {
38429       {
38430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38431       };
38432     }
38433   }
38434   jresult = new Dali::Animation((const Dali::Animation &)result);
38435   return jresult;
38436 }
38437
38438
38439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38440   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38441
38442   arg1 = (Dali::Animation *)jarg1;
38443   {
38444     try {
38445       delete arg1;
38446     } catch (std::out_of_range& e) {
38447       {
38448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38449       };
38450     } catch (std::exception& e) {
38451       {
38452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38453       };
38454     } catch (...) {
38455       {
38456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38457       };
38458     }
38459   }
38460 }
38461
38462
38463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38464   void * jresult ;
38465   Dali::Animation *arg1 = 0 ;
38466   Dali::Animation *result = 0 ;
38467
38468   arg1 = (Dali::Animation *)jarg1;
38469   if (!arg1) {
38470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38471     return 0;
38472   }
38473   {
38474     try {
38475       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38476     } catch (std::out_of_range& e) {
38477       {
38478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38479       };
38480     } catch (std::exception& e) {
38481       {
38482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38483       };
38484     } catch (...) {
38485       {
38486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38487       };
38488     }
38489   }
38490   jresult = (void *)result;
38491   return jresult;
38492 }
38493
38494
38495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38496   void * jresult ;
38497   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38498   Dali::Animation *arg2 = 0 ;
38499   Dali::Animation *result = 0 ;
38500
38501   arg1 = (Dali::Animation *)jarg1;
38502   arg2 = (Dali::Animation *)jarg2;
38503   if (!arg2) {
38504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38505     return 0;
38506   }
38507   {
38508     try {
38509       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38510     } catch (std::out_of_range& e) {
38511       {
38512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (std::exception& e) {
38515       {
38516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38517       };
38518     } catch (...) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38521       };
38522     }
38523   }
38524   jresult = (void *)result;
38525   return jresult;
38526 }
38527
38528
38529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38530   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38531   float arg2 ;
38532
38533   arg1 = (Dali::Animation *)jarg1;
38534   arg2 = (float)jarg2;
38535   {
38536     try {
38537       (arg1)->SetDuration(arg2);
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38545       };
38546     } catch (...) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38549       };
38550     }
38551   }
38552 }
38553
38554
38555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38556   float jresult ;
38557   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38558   float result;
38559
38560   arg1 = (Dali::Animation *)jarg1;
38561   {
38562     try {
38563       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38564     } catch (std::out_of_range& e) {
38565       {
38566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38567       };
38568     } catch (std::exception& e) {
38569       {
38570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38571       };
38572     } catch (...) {
38573       {
38574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38575       };
38576     }
38577   }
38578   jresult = result;
38579   return jresult;
38580 }
38581
38582
38583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38584   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38585   bool arg2 ;
38586
38587   arg1 = (Dali::Animation *)jarg1;
38588   arg2 = jarg2 ? true : false;
38589   {
38590     try {
38591       (arg1)->SetLooping(arg2);
38592     } catch (std::out_of_range& e) {
38593       {
38594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38595       };
38596     } catch (std::exception& e) {
38597       {
38598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38599       };
38600     } catch (...) {
38601       {
38602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38603       };
38604     }
38605   }
38606 }
38607
38608
38609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38610   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38611   int arg2 ;
38612
38613   arg1 = (Dali::Animation *)jarg1;
38614   arg2 = (int)jarg2;
38615   {
38616     try {
38617       (arg1)->SetLoopCount(arg2);
38618     } catch (std::out_of_range& e) {
38619       {
38620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38621       };
38622     } catch (std::exception& e) {
38623       {
38624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38625       };
38626     } catch (...) {
38627       {
38628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38629       };
38630     }
38631   }
38632 }
38633
38634
38635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38636   int jresult ;
38637   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38638   int result;
38639
38640   arg1 = (Dali::Animation *)jarg1;
38641   {
38642     try {
38643       result = (int)(arg1)->GetLoopCount();
38644     } catch (std::out_of_range& e) {
38645       {
38646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (std::exception& e) {
38649       {
38650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38655       };
38656     }
38657   }
38658   jresult = result;
38659   return jresult;
38660 }
38661
38662
38663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38664   int jresult ;
38665   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38666   int result;
38667
38668   arg1 = (Dali::Animation *)jarg1;
38669   {
38670     try {
38671       result = (int)(arg1)->GetCurrentLoop();
38672     } catch (std::out_of_range& e) {
38673       {
38674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38675       };
38676     } catch (std::exception& e) {
38677       {
38678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38679       };
38680     } catch (...) {
38681       {
38682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38683       };
38684     }
38685   }
38686   jresult = result;
38687   return jresult;
38688 }
38689
38690
38691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38692   unsigned int jresult ;
38693   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38694   bool result;
38695
38696   arg1 = (Dali::Animation *)jarg1;
38697   {
38698     try {
38699       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38700     } catch (std::out_of_range& e) {
38701       {
38702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38703       };
38704     } catch (std::exception& e) {
38705       {
38706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38707       };
38708     } catch (...) {
38709       {
38710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38711       };
38712     }
38713   }
38714   jresult = result;
38715   return jresult;
38716 }
38717
38718
38719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38720   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38721   Dali::Animation::EndAction arg2 ;
38722
38723   arg1 = (Dali::Animation *)jarg1;
38724   arg2 = (Dali::Animation::EndAction)jarg2;
38725   {
38726     try {
38727       (arg1)->SetEndAction(arg2);
38728     } catch (std::out_of_range& e) {
38729       {
38730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38731       };
38732     } catch (std::exception& e) {
38733       {
38734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38735       };
38736     } catch (...) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38739       };
38740     }
38741   }
38742 }
38743
38744
38745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38746   int jresult ;
38747   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38748   Dali::Animation::EndAction result;
38749
38750   arg1 = (Dali::Animation *)jarg1;
38751   {
38752     try {
38753       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38754     } catch (std::out_of_range& e) {
38755       {
38756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (std::exception& e) {
38759       {
38760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38761       };
38762     } catch (...) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38765       };
38766     }
38767   }
38768   jresult = (int)result;
38769   return jresult;
38770 }
38771
38772
38773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38774   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38775   Dali::Animation::EndAction arg2 ;
38776
38777   arg1 = (Dali::Animation *)jarg1;
38778   arg2 = (Dali::Animation::EndAction)jarg2;
38779   {
38780     try {
38781       (arg1)->SetDisconnectAction(arg2);
38782     } catch (std::out_of_range& e) {
38783       {
38784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38785       };
38786     } catch (std::exception& e) {
38787       {
38788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38789       };
38790     } catch (...) {
38791       {
38792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38793       };
38794     }
38795   }
38796 }
38797
38798
38799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38800   int jresult ;
38801   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38802   Dali::Animation::EndAction result;
38803
38804   arg1 = (Dali::Animation *)jarg1;
38805   {
38806     try {
38807       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38808     } catch (std::out_of_range& e) {
38809       {
38810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38811       };
38812     } catch (std::exception& e) {
38813       {
38814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38815       };
38816     } catch (...) {
38817       {
38818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38819       };
38820     }
38821   }
38822   jresult = (int)result;
38823   return jresult;
38824 }
38825
38826
38827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38828   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38829   Dali::AlphaFunction arg2 ;
38830   Dali::AlphaFunction *argp2 ;
38831
38832   arg1 = (Dali::Animation *)jarg1;
38833   argp2 = (Dali::AlphaFunction *)jarg2;
38834   if (!argp2) {
38835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38836     return ;
38837   }
38838   arg2 = *argp2;
38839   {
38840     try {
38841       (arg1)->SetDefaultAlphaFunction(arg2);
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38849       };
38850     } catch (...) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38853       };
38854     }
38855   }
38856 }
38857
38858
38859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38860   void * jresult ;
38861   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38862   Dali::AlphaFunction result;
38863
38864   arg1 = (Dali::Animation *)jarg1;
38865   {
38866     try {
38867       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38868     } catch (std::out_of_range& e) {
38869       {
38870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38871       };
38872     } catch (std::exception& e) {
38873       {
38874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38875       };
38876     } catch (...) {
38877       {
38878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38879       };
38880     }
38881   }
38882   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38883   return jresult;
38884 }
38885
38886
38887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38888   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38889   float arg2 ;
38890
38891   arg1 = (Dali::Animation *)jarg1;
38892   arg2 = (float)jarg2;
38893   {
38894     try {
38895       (arg1)->SetCurrentProgress(arg2);
38896     } catch (std::out_of_range& e) {
38897       {
38898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38899       };
38900     } catch (std::exception& e) {
38901       {
38902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38903       };
38904     } catch (...) {
38905       {
38906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38907       };
38908     }
38909   }
38910 }
38911
38912
38913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38914   float jresult ;
38915   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38916   float result;
38917
38918   arg1 = (Dali::Animation *)jarg1;
38919   {
38920     try {
38921       result = (float)(arg1)->GetCurrentProgress();
38922     } catch (std::out_of_range& e) {
38923       {
38924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38925       };
38926     } catch (std::exception& e) {
38927       {
38928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (...) {
38931       {
38932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38933       };
38934     }
38935   }
38936   jresult = result;
38937   return jresult;
38938 }
38939
38940
38941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38942   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38943   float arg2 ;
38944
38945   arg1 = (Dali::Animation *)jarg1;
38946   arg2 = (float)jarg2;
38947   {
38948     try {
38949       (arg1)->SetSpeedFactor(arg2);
38950     } catch (std::out_of_range& e) {
38951       {
38952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38953       };
38954     } catch (std::exception& e) {
38955       {
38956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38957       };
38958     } catch (...) {
38959       {
38960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38961       };
38962     }
38963   }
38964 }
38965
38966
38967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38968   float jresult ;
38969   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38970   float result;
38971
38972   arg1 = (Dali::Animation *)jarg1;
38973   {
38974     try {
38975       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38987       };
38988     }
38989   }
38990   jresult = result;
38991   return jresult;
38992 }
38993
38994
38995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38996   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38997   Dali::Vector2 *arg2 = 0 ;
38998
38999   arg1 = (Dali::Animation *)jarg1;
39000   arg2 = (Dali::Vector2 *)jarg2;
39001   if (!arg2) {
39002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39003     return ;
39004   }
39005   {
39006     try {
39007       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39015       };
39016     } catch (...) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39019       };
39020     }
39021   }
39022 }
39023
39024
39025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39026   void * jresult ;
39027   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39028   Dali::Vector2 result;
39029
39030   arg1 = (Dali::Animation *)jarg1;
39031   {
39032     try {
39033       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39034     } catch (std::out_of_range& e) {
39035       {
39036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39037       };
39038     } catch (std::exception& e) {
39039       {
39040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39041       };
39042     } catch (...) {
39043       {
39044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39045       };
39046     }
39047   }
39048   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39049   return jresult;
39050 }
39051
39052
39053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39054   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39055
39056   arg1 = (Dali::Animation *)jarg1;
39057   {
39058     try {
39059       (arg1)->Play();
39060     } catch (std::out_of_range& e) {
39061       {
39062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39063       };
39064     } catch (std::exception& e) {
39065       {
39066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39067       };
39068     } catch (...) {
39069       {
39070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39071       };
39072     }
39073   }
39074 }
39075
39076
39077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39078   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39079   float arg2 ;
39080
39081   arg1 = (Dali::Animation *)jarg1;
39082   arg2 = (float)jarg2;
39083   {
39084     try {
39085       (arg1)->PlayFrom(arg2);
39086     } catch (std::out_of_range& e) {
39087       {
39088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39089       };
39090     } catch (std::exception& e) {
39091       {
39092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39093       };
39094     } catch (...) {
39095       {
39096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39097       };
39098     }
39099   }
39100 }
39101
39102
39103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39104   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39105
39106   arg1 = (Dali::Animation *)jarg1;
39107   {
39108     try {
39109       (arg1)->Pause();
39110     } catch (std::out_of_range& e) {
39111       {
39112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39113       };
39114     } catch (std::exception& e) {
39115       {
39116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39117       };
39118     } catch (...) {
39119       {
39120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39121       };
39122     }
39123   }
39124 }
39125
39126
39127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39128   int jresult ;
39129   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39130   Dali::Animation::State result;
39131
39132   arg1 = (Dali::Animation *)jarg1;
39133   {
39134     try {
39135       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39136     } catch (std::out_of_range& e) {
39137       {
39138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39139       };
39140     } catch (std::exception& e) {
39141       {
39142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39143       };
39144     } catch (...) {
39145       {
39146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39147       };
39148     }
39149   }
39150   jresult = (int)result;
39151   return jresult;
39152 }
39153
39154
39155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39156   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39157
39158   arg1 = (Dali::Animation *)jarg1;
39159   {
39160     try {
39161       (arg1)->Stop();
39162     } catch (std::out_of_range& e) {
39163       {
39164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39165       };
39166     } catch (std::exception& e) {
39167       {
39168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39169       };
39170     } catch (...) {
39171       {
39172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39173       };
39174     }
39175   }
39176 }
39177
39178
39179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39180   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39181
39182   arg1 = (Dali::Animation *)jarg1;
39183   {
39184     try {
39185       (arg1)->Clear();
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39197       };
39198     }
39199   }
39200 }
39201
39202
39203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39204   void * jresult ;
39205   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39206   Dali::Animation::AnimationSignalType *result = 0 ;
39207
39208   arg1 = (Dali::Animation *)jarg1;
39209   {
39210     try {
39211       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39212     } catch (std::out_of_range& e) {
39213       {
39214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39215       };
39216     } catch (std::exception& e) {
39217       {
39218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39219       };
39220     } catch (...) {
39221       {
39222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39223       };
39224     }
39225   }
39226   jresult = (void *)result;
39227   return jresult;
39228 }
39229
39230
39231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39232   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39233   SwigValueWrapper< Dali::Property > arg2 ;
39234   Dali::Property::Value arg3 ;
39235   Dali::Property *argp2 ;
39236   Dali::Property::Value *argp3 ;
39237
39238   arg1 = (Dali::Animation *)jarg1;
39239   argp2 = (Dali::Property *)jarg2;
39240   if (!argp2) {
39241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39242     return ;
39243   }
39244   arg2 = *argp2;
39245   argp3 = (Dali::Property::Value *)jarg3;
39246   if (!argp3) {
39247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39248     return ;
39249   }
39250   arg3 = *argp3;
39251   {
39252     try {
39253       (arg1)->AnimateBy(arg2,arg3);
39254     } catch (std::out_of_range& e) {
39255       {
39256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39257       };
39258     } catch (std::exception& e) {
39259       {
39260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39261       };
39262     } catch (...) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39265       };
39266     }
39267   }
39268 }
39269
39270
39271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39272   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39273   SwigValueWrapper< Dali::Property > arg2 ;
39274   Dali::Property::Value arg3 ;
39275   Dali::AlphaFunction arg4 ;
39276   Dali::Property *argp2 ;
39277   Dali::Property::Value *argp3 ;
39278   Dali::AlphaFunction *argp4 ;
39279
39280   arg1 = (Dali::Animation *)jarg1;
39281   argp2 = (Dali::Property *)jarg2;
39282   if (!argp2) {
39283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39284     return ;
39285   }
39286   arg2 = *argp2;
39287   argp3 = (Dali::Property::Value *)jarg3;
39288   if (!argp3) {
39289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39290     return ;
39291   }
39292   arg3 = *argp3;
39293   argp4 = (Dali::AlphaFunction *)jarg4;
39294   if (!argp4) {
39295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39296     return ;
39297   }
39298   arg4 = *argp4;
39299   {
39300     try {
39301       (arg1)->AnimateBy(arg2,arg3,arg4);
39302     } catch (std::out_of_range& e) {
39303       {
39304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39305       };
39306     } catch (std::exception& e) {
39307       {
39308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (...) {
39311       {
39312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39313       };
39314     }
39315   }
39316 }
39317
39318
39319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39320   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39321   SwigValueWrapper< Dali::Property > arg2 ;
39322   Dali::Property::Value arg3 ;
39323   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39324   Dali::Property *argp2 ;
39325   Dali::Property::Value *argp3 ;
39326   Dali::TimePeriod *argp4 ;
39327
39328   arg1 = (Dali::Animation *)jarg1;
39329   argp2 = (Dali::Property *)jarg2;
39330   if (!argp2) {
39331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39332     return ;
39333   }
39334   arg2 = *argp2;
39335   argp3 = (Dali::Property::Value *)jarg3;
39336   if (!argp3) {
39337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39338     return ;
39339   }
39340   arg3 = *argp3;
39341   argp4 = (Dali::TimePeriod *)jarg4;
39342   if (!argp4) {
39343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39344     return ;
39345   }
39346   arg4 = *argp4;
39347   {
39348     try {
39349       (arg1)->AnimateBy(arg2,arg3,arg4);
39350     } catch (std::out_of_range& e) {
39351       {
39352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39353       };
39354     } catch (std::exception& e) {
39355       {
39356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39357       };
39358     } catch (...) {
39359       {
39360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39361       };
39362     }
39363   }
39364 }
39365
39366
39367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39368   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39369   SwigValueWrapper< Dali::Property > arg2 ;
39370   Dali::Property::Value arg3 ;
39371   Dali::AlphaFunction arg4 ;
39372   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39373   Dali::Property *argp2 ;
39374   Dali::Property::Value *argp3 ;
39375   Dali::AlphaFunction *argp4 ;
39376   Dali::TimePeriod *argp5 ;
39377
39378   arg1 = (Dali::Animation *)jarg1;
39379   argp2 = (Dali::Property *)jarg2;
39380   if (!argp2) {
39381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39382     return ;
39383   }
39384   arg2 = *argp2;
39385   argp3 = (Dali::Property::Value *)jarg3;
39386   if (!argp3) {
39387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39388     return ;
39389   }
39390   arg3 = *argp3;
39391   argp4 = (Dali::AlphaFunction *)jarg4;
39392   if (!argp4) {
39393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39394     return ;
39395   }
39396   arg4 = *argp4;
39397   argp5 = (Dali::TimePeriod *)jarg5;
39398   if (!argp5) {
39399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39400     return ;
39401   }
39402   arg5 = *argp5;
39403   {
39404     try {
39405       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39406     } catch (std::out_of_range& e) {
39407       {
39408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39409       };
39410     } catch (std::exception& e) {
39411       {
39412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39413       };
39414     } catch (...) {
39415       {
39416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39417       };
39418     }
39419   }
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39424   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39425   SwigValueWrapper< Dali::Property > arg2 ;
39426   Dali::Property::Value arg3 ;
39427   Dali::Property *argp2 ;
39428   Dali::Property::Value *argp3 ;
39429
39430   arg1 = (Dali::Animation *)jarg1;
39431   argp2 = (Dali::Property *)jarg2;
39432   if (!argp2) {
39433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39434     return ;
39435   }
39436   arg2 = *argp2;
39437   argp3 = (Dali::Property::Value *)jarg3;
39438   if (!argp3) {
39439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39440     return ;
39441   }
39442   arg3 = *argp3;
39443   {
39444     try {
39445       (arg1)->AnimateTo(arg2,arg3);
39446     } catch (std::out_of_range& e) {
39447       {
39448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39449       };
39450     } catch (std::exception& e) {
39451       {
39452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39453       };
39454     } catch (...) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39457       };
39458     }
39459   }
39460 }
39461
39462
39463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39464   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39465   SwigValueWrapper< Dali::Property > arg2 ;
39466   Dali::Property::Value arg3 ;
39467   Dali::AlphaFunction arg4 ;
39468   Dali::Property *argp2 ;
39469   Dali::Property::Value *argp3 ;
39470   Dali::AlphaFunction *argp4 ;
39471
39472   arg1 = (Dali::Animation *)jarg1;
39473   argp2 = (Dali::Property *)jarg2;
39474   if (!argp2) {
39475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39476     return ;
39477   }
39478   arg2 = *argp2;
39479   argp3 = (Dali::Property::Value *)jarg3;
39480   if (!argp3) {
39481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39482     return ;
39483   }
39484   arg3 = *argp3;
39485   argp4 = (Dali::AlphaFunction *)jarg4;
39486   if (!argp4) {
39487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39488     return ;
39489   }
39490   arg4 = *argp4;
39491   {
39492     try {
39493       (arg1)->AnimateTo(arg2,arg3,arg4);
39494     } catch (std::out_of_range& e) {
39495       {
39496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39497       };
39498     } catch (std::exception& e) {
39499       {
39500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39501       };
39502     } catch (...) {
39503       {
39504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39505       };
39506     }
39507   }
39508 }
39509
39510
39511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39512   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39513   SwigValueWrapper< Dali::Property > arg2 ;
39514   Dali::Property::Value arg3 ;
39515   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39516   Dali::Property *argp2 ;
39517   Dali::Property::Value *argp3 ;
39518   Dali::TimePeriod *argp4 ;
39519
39520   arg1 = (Dali::Animation *)jarg1;
39521   argp2 = (Dali::Property *)jarg2;
39522   if (!argp2) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39524     return ;
39525   }
39526   arg2 = *argp2;
39527   argp3 = (Dali::Property::Value *)jarg3;
39528   if (!argp3) {
39529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39530     return ;
39531   }
39532   arg3 = *argp3;
39533   argp4 = (Dali::TimePeriod *)jarg4;
39534   if (!argp4) {
39535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39536     return ;
39537   }
39538   arg4 = *argp4;
39539   {
39540     try {
39541       (arg1)->AnimateTo(arg2,arg3,arg4);
39542     } catch (std::out_of_range& e) {
39543       {
39544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39545       };
39546     } catch (std::exception& e) {
39547       {
39548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39549       };
39550     } catch (...) {
39551       {
39552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39553       };
39554     }
39555   }
39556 }
39557
39558
39559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39560   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39561   SwigValueWrapper< Dali::Property > arg2 ;
39562   Dali::Property::Value arg3 ;
39563   Dali::AlphaFunction arg4 ;
39564   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39565   Dali::Property *argp2 ;
39566   Dali::Property::Value *argp3 ;
39567   Dali::AlphaFunction *argp4 ;
39568   Dali::TimePeriod *argp5 ;
39569
39570   arg1 = (Dali::Animation *)jarg1;
39571   argp2 = (Dali::Property *)jarg2;
39572   if (!argp2) {
39573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39574     return ;
39575   }
39576   arg2 = *argp2;
39577   argp3 = (Dali::Property::Value *)jarg3;
39578   if (!argp3) {
39579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39580     return ;
39581   }
39582   arg3 = *argp3;
39583   argp4 = (Dali::AlphaFunction *)jarg4;
39584   if (!argp4) {
39585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39586     return ;
39587   }
39588   arg4 = *argp4;
39589   argp5 = (Dali::TimePeriod *)jarg5;
39590   if (!argp5) {
39591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39592     return ;
39593   }
39594   arg5 = *argp5;
39595   {
39596     try {
39597       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39598     } catch (std::out_of_range& e) {
39599       {
39600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39601       };
39602     } catch (std::exception& e) {
39603       {
39604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39605       };
39606     } catch (...) {
39607       {
39608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39609       };
39610     }
39611   }
39612 }
39613
39614
39615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39616   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39617   SwigValueWrapper< Dali::Property > arg2 ;
39618   Dali::KeyFrames *arg3 = 0 ;
39619   Dali::Property *argp2 ;
39620
39621   arg1 = (Dali::Animation *)jarg1;
39622   argp2 = (Dali::Property *)jarg2;
39623   if (!argp2) {
39624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39625     return ;
39626   }
39627   arg2 = *argp2;
39628   arg3 = (Dali::KeyFrames *)jarg3;
39629   if (!arg3) {
39630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39631     return ;
39632   }
39633   {
39634     try {
39635       (arg1)->AnimateBetween(arg2,*arg3);
39636     } catch (std::out_of_range& e) {
39637       {
39638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39639       };
39640     } catch (std::exception& e) {
39641       {
39642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39643       };
39644     } catch (...) {
39645       {
39646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39647       };
39648     }
39649   }
39650 }
39651
39652
39653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39654   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39655   SwigValueWrapper< Dali::Property > arg2 ;
39656   Dali::KeyFrames *arg3 = 0 ;
39657   Dali::Animation::Interpolation arg4 ;
39658   Dali::Property *argp2 ;
39659
39660   arg1 = (Dali::Animation *)jarg1;
39661   argp2 = (Dali::Property *)jarg2;
39662   if (!argp2) {
39663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39664     return ;
39665   }
39666   arg2 = *argp2;
39667   arg3 = (Dali::KeyFrames *)jarg3;
39668   if (!arg3) {
39669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39670     return ;
39671   }
39672   arg4 = (Dali::Animation::Interpolation)jarg4;
39673   {
39674     try {
39675       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39676     } catch (std::out_of_range& e) {
39677       {
39678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39679       };
39680     } catch (std::exception& e) {
39681       {
39682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39683       };
39684     } catch (...) {
39685       {
39686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39687       };
39688     }
39689   }
39690 }
39691
39692
39693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39694   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39695   SwigValueWrapper< Dali::Property > arg2 ;
39696   Dali::KeyFrames *arg3 = 0 ;
39697   Dali::AlphaFunction arg4 ;
39698   Dali::Property *argp2 ;
39699   Dali::AlphaFunction *argp4 ;
39700
39701   arg1 = (Dali::Animation *)jarg1;
39702   argp2 = (Dali::Property *)jarg2;
39703   if (!argp2) {
39704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39705     return ;
39706   }
39707   arg2 = *argp2;
39708   arg3 = (Dali::KeyFrames *)jarg3;
39709   if (!arg3) {
39710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39711     return ;
39712   }
39713   argp4 = (Dali::AlphaFunction *)jarg4;
39714   if (!argp4) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39716     return ;
39717   }
39718   arg4 = *argp4;
39719   {
39720     try {
39721       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39722     } catch (std::out_of_range& e) {
39723       {
39724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39725       };
39726     } catch (std::exception& e) {
39727       {
39728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39733       };
39734     }
39735   }
39736 }
39737
39738
39739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39741   SwigValueWrapper< Dali::Property > arg2 ;
39742   Dali::KeyFrames *arg3 = 0 ;
39743   Dali::AlphaFunction arg4 ;
39744   Dali::Animation::Interpolation arg5 ;
39745   Dali::Property *argp2 ;
39746   Dali::AlphaFunction *argp4 ;
39747
39748   arg1 = (Dali::Animation *)jarg1;
39749   argp2 = (Dali::Property *)jarg2;
39750   if (!argp2) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39752     return ;
39753   }
39754   arg2 = *argp2;
39755   arg3 = (Dali::KeyFrames *)jarg3;
39756   if (!arg3) {
39757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39758     return ;
39759   }
39760   argp4 = (Dali::AlphaFunction *)jarg4;
39761   if (!argp4) {
39762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39763     return ;
39764   }
39765   arg4 = *argp4;
39766   arg5 = (Dali::Animation::Interpolation)jarg5;
39767   {
39768     try {
39769       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39770     } catch (std::out_of_range& e) {
39771       {
39772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39773       };
39774     } catch (std::exception& e) {
39775       {
39776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39781       };
39782     }
39783   }
39784 }
39785
39786
39787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39788   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39789   SwigValueWrapper< Dali::Property > arg2 ;
39790   Dali::KeyFrames *arg3 = 0 ;
39791   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39792   Dali::Property *argp2 ;
39793   Dali::TimePeriod *argp4 ;
39794
39795   arg1 = (Dali::Animation *)jarg1;
39796   argp2 = (Dali::Property *)jarg2;
39797   if (!argp2) {
39798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39799     return ;
39800   }
39801   arg2 = *argp2;
39802   arg3 = (Dali::KeyFrames *)jarg3;
39803   if (!arg3) {
39804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39805     return ;
39806   }
39807   argp4 = (Dali::TimePeriod *)jarg4;
39808   if (!argp4) {
39809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39810     return ;
39811   }
39812   arg4 = *argp4;
39813   {
39814     try {
39815       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39816     } catch (std::out_of_range& e) {
39817       {
39818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39819       };
39820     } catch (std::exception& e) {
39821       {
39822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39823       };
39824     } catch (...) {
39825       {
39826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39827       };
39828     }
39829   }
39830 }
39831
39832
39833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39834   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39835   SwigValueWrapper< Dali::Property > arg2 ;
39836   Dali::KeyFrames *arg3 = 0 ;
39837   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39838   Dali::Animation::Interpolation arg5 ;
39839   Dali::Property *argp2 ;
39840   Dali::TimePeriod *argp4 ;
39841
39842   arg1 = (Dali::Animation *)jarg1;
39843   argp2 = (Dali::Property *)jarg2;
39844   if (!argp2) {
39845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39846     return ;
39847   }
39848   arg2 = *argp2;
39849   arg3 = (Dali::KeyFrames *)jarg3;
39850   if (!arg3) {
39851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39852     return ;
39853   }
39854   argp4 = (Dali::TimePeriod *)jarg4;
39855   if (!argp4) {
39856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39857     return ;
39858   }
39859   arg4 = *argp4;
39860   arg5 = (Dali::Animation::Interpolation)jarg5;
39861   {
39862     try {
39863       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39864     } catch (std::out_of_range& e) {
39865       {
39866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39867       };
39868     } catch (std::exception& e) {
39869       {
39870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39871       };
39872     } catch (...) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39875       };
39876     }
39877   }
39878 }
39879
39880
39881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39882   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39883   SwigValueWrapper< Dali::Property > arg2 ;
39884   Dali::KeyFrames *arg3 = 0 ;
39885   Dali::AlphaFunction arg4 ;
39886   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39887   Dali::Property *argp2 ;
39888   Dali::AlphaFunction *argp4 ;
39889   Dali::TimePeriod *argp5 ;
39890
39891   arg1 = (Dali::Animation *)jarg1;
39892   argp2 = (Dali::Property *)jarg2;
39893   if (!argp2) {
39894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39895     return ;
39896   }
39897   arg2 = *argp2;
39898   arg3 = (Dali::KeyFrames *)jarg3;
39899   if (!arg3) {
39900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39901     return ;
39902   }
39903   argp4 = (Dali::AlphaFunction *)jarg4;
39904   if (!argp4) {
39905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39906     return ;
39907   }
39908   arg4 = *argp4;
39909   argp5 = (Dali::TimePeriod *)jarg5;
39910   if (!argp5) {
39911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39912     return ;
39913   }
39914   arg5 = *argp5;
39915   {
39916     try {
39917       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39918     } catch (std::out_of_range& e) {
39919       {
39920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39921       };
39922     } catch (std::exception& e) {
39923       {
39924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39925       };
39926     } catch (...) {
39927       {
39928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39929       };
39930     }
39931   }
39932 }
39933
39934
39935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39936   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39937   SwigValueWrapper< Dali::Property > arg2 ;
39938   Dali::KeyFrames *arg3 = 0 ;
39939   Dali::AlphaFunction arg4 ;
39940   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39941   Dali::Animation::Interpolation arg6 ;
39942   Dali::Property *argp2 ;
39943   Dali::AlphaFunction *argp4 ;
39944   Dali::TimePeriod *argp5 ;
39945
39946   arg1 = (Dali::Animation *)jarg1;
39947   argp2 = (Dali::Property *)jarg2;
39948   if (!argp2) {
39949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39950     return ;
39951   }
39952   arg2 = *argp2;
39953   arg3 = (Dali::KeyFrames *)jarg3;
39954   if (!arg3) {
39955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39956     return ;
39957   }
39958   argp4 = (Dali::AlphaFunction *)jarg4;
39959   if (!argp4) {
39960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39961     return ;
39962   }
39963   arg4 = *argp4;
39964   argp5 = (Dali::TimePeriod *)jarg5;
39965   if (!argp5) {
39966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39967     return ;
39968   }
39969   arg5 = *argp5;
39970   arg6 = (Dali::Animation::Interpolation)jarg6;
39971   {
39972     try {
39973       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39974     } catch (std::out_of_range& e) {
39975       {
39976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39977       };
39978     } catch (std::exception& e) {
39979       {
39980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39981       };
39982     } catch (...) {
39983       {
39984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39985       };
39986     }
39987   }
39988 }
39989
39990
39991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39992   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39993   Dali::Actor arg2 ;
39994   Dali::Path arg3 ;
39995   Dali::Vector3 *arg4 = 0 ;
39996   Dali::Actor *argp2 ;
39997   Dali::Path *argp3 ;
39998
39999   arg1 = (Dali::Animation *)jarg1;
40000   argp2 = (Dali::Actor *)jarg2;
40001   if (!argp2) {
40002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40003     return ;
40004   }
40005   arg2 = *argp2;
40006   argp3 = (Dali::Path *)jarg3;
40007   if (!argp3) {
40008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40009     return ;
40010   }
40011   arg3 = *argp3;
40012   arg4 = (Dali::Vector3 *)jarg4;
40013   if (!arg4) {
40014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40015     return ;
40016   }
40017   {
40018     try {
40019       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40020     } catch (std::out_of_range& e) {
40021       {
40022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40023       };
40024     } catch (std::exception& e) {
40025       {
40026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40027       };
40028     } catch (...) {
40029       {
40030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40031       };
40032     }
40033   }
40034 }
40035
40036
40037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40038   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40039   Dali::Actor arg2 ;
40040   Dali::Path arg3 ;
40041   Dali::Vector3 *arg4 = 0 ;
40042   Dali::AlphaFunction arg5 ;
40043   Dali::Actor *argp2 ;
40044   Dali::Path *argp3 ;
40045   Dali::AlphaFunction *argp5 ;
40046
40047   arg1 = (Dali::Animation *)jarg1;
40048   argp2 = (Dali::Actor *)jarg2;
40049   if (!argp2) {
40050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40051     return ;
40052   }
40053   arg2 = *argp2;
40054   argp3 = (Dali::Path *)jarg3;
40055   if (!argp3) {
40056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40057     return ;
40058   }
40059   arg3 = *argp3;
40060   arg4 = (Dali::Vector3 *)jarg4;
40061   if (!arg4) {
40062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40063     return ;
40064   }
40065   argp5 = (Dali::AlphaFunction *)jarg5;
40066   if (!argp5) {
40067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40068     return ;
40069   }
40070   arg5 = *argp5;
40071   {
40072     try {
40073       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40074     } catch (std::out_of_range& e) {
40075       {
40076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40077       };
40078     } catch (std::exception& e) {
40079       {
40080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40081       };
40082     } catch (...) {
40083       {
40084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40085       };
40086     }
40087   }
40088 }
40089
40090
40091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40092   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40093   Dali::Actor arg2 ;
40094   Dali::Path arg3 ;
40095   Dali::Vector3 *arg4 = 0 ;
40096   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40097   Dali::Actor *argp2 ;
40098   Dali::Path *argp3 ;
40099   Dali::TimePeriod *argp5 ;
40100
40101   arg1 = (Dali::Animation *)jarg1;
40102   argp2 = (Dali::Actor *)jarg2;
40103   if (!argp2) {
40104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40105     return ;
40106   }
40107   arg2 = *argp2;
40108   argp3 = (Dali::Path *)jarg3;
40109   if (!argp3) {
40110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40111     return ;
40112   }
40113   arg3 = *argp3;
40114   arg4 = (Dali::Vector3 *)jarg4;
40115   if (!arg4) {
40116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40117     return ;
40118   }
40119   argp5 = (Dali::TimePeriod *)jarg5;
40120   if (!argp5) {
40121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40122     return ;
40123   }
40124   arg5 = *argp5;
40125   {
40126     try {
40127       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40128     } catch (std::out_of_range& e) {
40129       {
40130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40131       };
40132     } catch (std::exception& e) {
40133       {
40134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40135       };
40136     } catch (...) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40139       };
40140     }
40141   }
40142 }
40143
40144
40145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40146   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40147   Dali::Actor arg2 ;
40148   Dali::Path arg3 ;
40149   Dali::Vector3 *arg4 = 0 ;
40150   Dali::AlphaFunction arg5 ;
40151   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40152   Dali::Actor *argp2 ;
40153   Dali::Path *argp3 ;
40154   Dali::AlphaFunction *argp5 ;
40155   Dali::TimePeriod *argp6 ;
40156
40157   arg1 = (Dali::Animation *)jarg1;
40158   argp2 = (Dali::Actor *)jarg2;
40159   if (!argp2) {
40160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40161     return ;
40162   }
40163   arg2 = *argp2;
40164   argp3 = (Dali::Path *)jarg3;
40165   if (!argp3) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40167     return ;
40168   }
40169   arg3 = *argp3;
40170   arg4 = (Dali::Vector3 *)jarg4;
40171   if (!arg4) {
40172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40173     return ;
40174   }
40175   argp5 = (Dali::AlphaFunction *)jarg5;
40176   if (!argp5) {
40177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40178     return ;
40179   }
40180   arg5 = *argp5;
40181   argp6 = (Dali::TimePeriod *)jarg6;
40182   if (!argp6) {
40183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40184     return ;
40185   }
40186   arg6 = *argp6;
40187   {
40188     try {
40189       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40190     } catch (std::out_of_range& e) {
40191       {
40192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40193       };
40194     } catch (std::exception& e) {
40195       {
40196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40197       };
40198     } catch (...) {
40199       {
40200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40201       };
40202     }
40203   }
40204 }
40205
40206
40207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40208   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40209   Dali::Actor arg2 ;
40210   float arg3 ;
40211   Dali::Actor *argp2 ;
40212
40213   arg1 = (Dali::Animation *)jarg1;
40214   argp2 = (Dali::Actor *)jarg2;
40215   if (!argp2) {
40216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40217     return ;
40218   }
40219   arg2 = *argp2;
40220   arg3 = (float)jarg3;
40221   {
40222     try {
40223       (arg1)->Show(arg2,arg3);
40224     } catch (std::out_of_range& e) {
40225       {
40226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40227       };
40228     } catch (std::exception& e) {
40229       {
40230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40231       };
40232     } catch (...) {
40233       {
40234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40235       };
40236     }
40237   }
40238 }
40239
40240
40241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40242   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40243   Dali::Actor arg2 ;
40244   float arg3 ;
40245   Dali::Actor *argp2 ;
40246
40247   arg1 = (Dali::Animation *)jarg1;
40248   argp2 = (Dali::Actor *)jarg2;
40249   if (!argp2) {
40250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40251     return ;
40252   }
40253   arg2 = *argp2;
40254   arg3 = (float)jarg3;
40255   {
40256     try {
40257       (arg1)->Hide(arg2,arg3);
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40265       };
40266     } catch (...) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40269       };
40270     }
40271   }
40272 }
40273
40274
40275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40276   int jresult ;
40277   int result;
40278
40279   result = (int)Dali::LinearConstrainer::Property::VALUE;
40280   jresult = (int)result;
40281   return jresult;
40282 }
40283
40284
40285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40286   int jresult ;
40287   int result;
40288
40289   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40290   jresult = (int)result;
40291   return jresult;
40292 }
40293
40294
40295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40296   void * jresult ;
40297   Dali::LinearConstrainer::Property *result = 0 ;
40298
40299   {
40300     try {
40301       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40302     } catch (std::out_of_range& e) {
40303       {
40304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40305       };
40306     } catch (std::exception& e) {
40307       {
40308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40309       };
40310     } catch (...) {
40311       {
40312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40313       };
40314     }
40315   }
40316   jresult = (void *)result;
40317   return jresult;
40318 }
40319
40320
40321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40322   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40323
40324   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40325   {
40326     try {
40327       delete arg1;
40328     } catch (std::out_of_range& e) {
40329       {
40330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40331       };
40332     } catch (std::exception& e) {
40333       {
40334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40335       };
40336     } catch (...) {
40337       {
40338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40339       };
40340     }
40341   }
40342 }
40343
40344
40345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40346   void * jresult ;
40347   Dali::LinearConstrainer result;
40348
40349   {
40350     try {
40351       result = Dali::LinearConstrainer::New();
40352     } catch (std::out_of_range& e) {
40353       {
40354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40355       };
40356     } catch (std::exception& e) {
40357       {
40358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40359       };
40360     } catch (...) {
40361       {
40362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40363       };
40364     }
40365   }
40366   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40367   return jresult;
40368 }
40369
40370
40371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40372   void * jresult ;
40373   Dali::BaseHandle arg1 ;
40374   Dali::BaseHandle *argp1 ;
40375   Dali::LinearConstrainer result;
40376
40377   argp1 = (Dali::BaseHandle *)jarg1;
40378   if (!argp1) {
40379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40380     return 0;
40381   }
40382   arg1 = *argp1;
40383   {
40384     try {
40385       result = Dali::LinearConstrainer::DownCast(arg1);
40386     } catch (std::out_of_range& e) {
40387       {
40388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40389       };
40390     } catch (std::exception& e) {
40391       {
40392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (...) {
40395       {
40396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40397       };
40398     }
40399   }
40400   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40401   return jresult;
40402 }
40403
40404
40405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40406   void * jresult ;
40407   Dali::LinearConstrainer *result = 0 ;
40408
40409   {
40410     try {
40411       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40412     } catch (std::out_of_range& e) {
40413       {
40414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40415       };
40416     } catch (std::exception& e) {
40417       {
40418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40419       };
40420     } catch (...) {
40421       {
40422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40423       };
40424     }
40425   }
40426   jresult = (void *)result;
40427   return jresult;
40428 }
40429
40430
40431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40432   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40433
40434   arg1 = (Dali::LinearConstrainer *)jarg1;
40435   {
40436     try {
40437       delete arg1;
40438     } catch (std::out_of_range& e) {
40439       {
40440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40441       };
40442     } catch (std::exception& e) {
40443       {
40444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40445       };
40446     } catch (...) {
40447       {
40448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40449       };
40450     }
40451   }
40452 }
40453
40454
40455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40456   void * jresult ;
40457   Dali::LinearConstrainer *arg1 = 0 ;
40458   Dali::LinearConstrainer *result = 0 ;
40459
40460   arg1 = (Dali::LinearConstrainer *)jarg1;
40461   if (!arg1) {
40462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40463     return 0;
40464   }
40465   {
40466     try {
40467       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40468     } catch (std::out_of_range& e) {
40469       {
40470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40471       };
40472     } catch (std::exception& e) {
40473       {
40474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40475       };
40476     } catch (...) {
40477       {
40478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40479       };
40480     }
40481   }
40482   jresult = (void *)result;
40483   return jresult;
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40488   void * jresult ;
40489   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40490   Dali::LinearConstrainer *arg2 = 0 ;
40491   Dali::LinearConstrainer *result = 0 ;
40492
40493   arg1 = (Dali::LinearConstrainer *)jarg1;
40494   arg2 = (Dali::LinearConstrainer *)jarg2;
40495   if (!arg2) {
40496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40497     return 0;
40498   }
40499   {
40500     try {
40501       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40502     } catch (std::out_of_range& e) {
40503       {
40504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40505       };
40506     } catch (std::exception& e) {
40507       {
40508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40509       };
40510     } catch (...) {
40511       {
40512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40513       };
40514     }
40515   }
40516   jresult = (void *)result;
40517   return jresult;
40518 }
40519
40520
40521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40522   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40523   SwigValueWrapper< Dali::Property > arg2 ;
40524   SwigValueWrapper< Dali::Property > arg3 ;
40525   Dali::Vector2 *arg4 = 0 ;
40526   Dali::Vector2 *arg5 = 0 ;
40527   Dali::Property *argp2 ;
40528   Dali::Property *argp3 ;
40529
40530   arg1 = (Dali::LinearConstrainer *)jarg1;
40531   argp2 = (Dali::Property *)jarg2;
40532   if (!argp2) {
40533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40534     return ;
40535   }
40536   arg2 = *argp2;
40537   argp3 = (Dali::Property *)jarg3;
40538   if (!argp3) {
40539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40540     return ;
40541   }
40542   arg3 = *argp3;
40543   arg4 = (Dali::Vector2 *)jarg4;
40544   if (!arg4) {
40545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40546     return ;
40547   }
40548   arg5 = (Dali::Vector2 *)jarg5;
40549   if (!arg5) {
40550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40551     return ;
40552   }
40553   {
40554     try {
40555       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40556     } catch (std::out_of_range& e) {
40557       {
40558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40559       };
40560     } catch (std::exception& e) {
40561       {
40562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40563       };
40564     } catch (...) {
40565       {
40566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40567       };
40568     }
40569   }
40570 }
40571
40572
40573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40574   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40575   SwigValueWrapper< Dali::Property > arg2 ;
40576   SwigValueWrapper< Dali::Property > arg3 ;
40577   Dali::Vector2 *arg4 = 0 ;
40578   Dali::Property *argp2 ;
40579   Dali::Property *argp3 ;
40580
40581   arg1 = (Dali::LinearConstrainer *)jarg1;
40582   argp2 = (Dali::Property *)jarg2;
40583   if (!argp2) {
40584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40585     return ;
40586   }
40587   arg2 = *argp2;
40588   argp3 = (Dali::Property *)jarg3;
40589   if (!argp3) {
40590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40591     return ;
40592   }
40593   arg3 = *argp3;
40594   arg4 = (Dali::Vector2 *)jarg4;
40595   if (!arg4) {
40596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40597     return ;
40598   }
40599   {
40600     try {
40601       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40602     } catch (std::out_of_range& e) {
40603       {
40604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40605       };
40606     } catch (std::exception& e) {
40607       {
40608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40613       };
40614     }
40615   }
40616 }
40617
40618
40619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40620   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40621   Dali::Handle *arg2 = 0 ;
40622
40623   arg1 = (Dali::LinearConstrainer *)jarg1;
40624   arg2 = (Dali::Handle *)jarg2;
40625   if (!arg2) {
40626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40627     return ;
40628   }
40629   {
40630     try {
40631       (arg1)->Remove(*arg2);
40632     } catch (std::out_of_range& e) {
40633       {
40634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40635       };
40636     } catch (std::exception& e) {
40637       {
40638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40639       };
40640     } catch (...) {
40641       {
40642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40643       };
40644     }
40645   }
40646 }
40647
40648
40649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40650   int jresult ;
40651   int result;
40652
40653   result = (int)Dali::PathConstrainer::Property::FORWARD;
40654   jresult = (int)result;
40655   return jresult;
40656 }
40657
40658
40659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40660   int jresult ;
40661   int result;
40662
40663   result = (int)Dali::PathConstrainer::Property::POINTS;
40664   jresult = (int)result;
40665   return jresult;
40666 }
40667
40668
40669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40670   int jresult ;
40671   int result;
40672
40673   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40674   jresult = (int)result;
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40680   void * jresult ;
40681   Dali::PathConstrainer::Property *result = 0 ;
40682
40683   {
40684     try {
40685       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40686     } catch (std::out_of_range& e) {
40687       {
40688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40689       };
40690     } catch (std::exception& e) {
40691       {
40692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40693       };
40694     } catch (...) {
40695       {
40696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40697       };
40698     }
40699   }
40700   jresult = (void *)result;
40701   return jresult;
40702 }
40703
40704
40705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40706   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40707
40708   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40709   {
40710     try {
40711       delete arg1;
40712     } catch (std::out_of_range& e) {
40713       {
40714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40715       };
40716     } catch (std::exception& e) {
40717       {
40718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40719       };
40720     } catch (...) {
40721       {
40722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40723       };
40724     }
40725   }
40726 }
40727
40728
40729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40730   void * jresult ;
40731   Dali::PathConstrainer result;
40732
40733   {
40734     try {
40735       result = Dali::PathConstrainer::New();
40736     } catch (std::out_of_range& e) {
40737       {
40738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40739       };
40740     } catch (std::exception& e) {
40741       {
40742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40743       };
40744     } catch (...) {
40745       {
40746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40747       };
40748     }
40749   }
40750   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40751   return jresult;
40752 }
40753
40754
40755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40756   void * jresult ;
40757   Dali::BaseHandle arg1 ;
40758   Dali::BaseHandle *argp1 ;
40759   Dali::PathConstrainer result;
40760
40761   argp1 = (Dali::BaseHandle *)jarg1;
40762   if (!argp1) {
40763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40764     return 0;
40765   }
40766   arg1 = *argp1;
40767   {
40768     try {
40769       result = Dali::PathConstrainer::DownCast(arg1);
40770     } catch (std::out_of_range& e) {
40771       {
40772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40773       };
40774     } catch (std::exception& e) {
40775       {
40776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40781       };
40782     }
40783   }
40784   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40785   return jresult;
40786 }
40787
40788
40789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40790   void * jresult ;
40791   Dali::PathConstrainer *result = 0 ;
40792
40793   {
40794     try {
40795       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40796     } catch (std::out_of_range& e) {
40797       {
40798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40799       };
40800     } catch (std::exception& e) {
40801       {
40802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40803       };
40804     } catch (...) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40807       };
40808     }
40809   }
40810   jresult = (void *)result;
40811   return jresult;
40812 }
40813
40814
40815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40816   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40817
40818   arg1 = (Dali::PathConstrainer *)jarg1;
40819   {
40820     try {
40821       delete arg1;
40822     } catch (std::out_of_range& e) {
40823       {
40824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40825       };
40826     } catch (std::exception& e) {
40827       {
40828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (...) {
40831       {
40832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40833       };
40834     }
40835   }
40836 }
40837
40838
40839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40840   void * jresult ;
40841   Dali::PathConstrainer *arg1 = 0 ;
40842   Dali::PathConstrainer *result = 0 ;
40843
40844   arg1 = (Dali::PathConstrainer *)jarg1;
40845   if (!arg1) {
40846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40847     return 0;
40848   }
40849   {
40850     try {
40851       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40852     } catch (std::out_of_range& e) {
40853       {
40854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40855       };
40856     } catch (std::exception& e) {
40857       {
40858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40859       };
40860     } catch (...) {
40861       {
40862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40863       };
40864     }
40865   }
40866   jresult = (void *)result;
40867   return jresult;
40868 }
40869
40870
40871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40872   void * jresult ;
40873   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40874   Dali::PathConstrainer *arg2 = 0 ;
40875   Dali::PathConstrainer *result = 0 ;
40876
40877   arg1 = (Dali::PathConstrainer *)jarg1;
40878   arg2 = (Dali::PathConstrainer *)jarg2;
40879   if (!arg2) {
40880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40881     return 0;
40882   }
40883   {
40884     try {
40885       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40886     } catch (std::out_of_range& e) {
40887       {
40888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40889       };
40890     } catch (std::exception& e) {
40891       {
40892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40893       };
40894     } catch (...) {
40895       {
40896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40897       };
40898     }
40899   }
40900   jresult = (void *)result;
40901   return jresult;
40902 }
40903
40904
40905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40906   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40907   SwigValueWrapper< Dali::Property > arg2 ;
40908   SwigValueWrapper< Dali::Property > arg3 ;
40909   Dali::Vector2 *arg4 = 0 ;
40910   Dali::Vector2 *arg5 = 0 ;
40911   Dali::Property *argp2 ;
40912   Dali::Property *argp3 ;
40913
40914   arg1 = (Dali::PathConstrainer *)jarg1;
40915   argp2 = (Dali::Property *)jarg2;
40916   if (!argp2) {
40917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40918     return ;
40919   }
40920   arg2 = *argp2;
40921   argp3 = (Dali::Property *)jarg3;
40922   if (!argp3) {
40923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40924     return ;
40925   }
40926   arg3 = *argp3;
40927   arg4 = (Dali::Vector2 *)jarg4;
40928   if (!arg4) {
40929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40930     return ;
40931   }
40932   arg5 = (Dali::Vector2 *)jarg5;
40933   if (!arg5) {
40934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40935     return ;
40936   }
40937   {
40938     try {
40939       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40940     } catch (std::out_of_range& e) {
40941       {
40942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40943       };
40944     } catch (std::exception& e) {
40945       {
40946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40947       };
40948     } catch (...) {
40949       {
40950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40951       };
40952     }
40953   }
40954 }
40955
40956
40957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40958   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40959   SwigValueWrapper< Dali::Property > arg2 ;
40960   SwigValueWrapper< Dali::Property > arg3 ;
40961   Dali::Vector2 *arg4 = 0 ;
40962   Dali::Property *argp2 ;
40963   Dali::Property *argp3 ;
40964
40965   arg1 = (Dali::PathConstrainer *)jarg1;
40966   argp2 = (Dali::Property *)jarg2;
40967   if (!argp2) {
40968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40969     return ;
40970   }
40971   arg2 = *argp2;
40972   argp3 = (Dali::Property *)jarg3;
40973   if (!argp3) {
40974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40975     return ;
40976   }
40977   arg3 = *argp3;
40978   arg4 = (Dali::Vector2 *)jarg4;
40979   if (!arg4) {
40980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40981     return ;
40982   }
40983   {
40984     try {
40985       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40986     } catch (std::out_of_range& e) {
40987       {
40988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40989       };
40990     } catch (std::exception& e) {
40991       {
40992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40993       };
40994     } catch (...) {
40995       {
40996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40997       };
40998     }
40999   }
41000 }
41001
41002
41003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41004   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41005   Dali::Handle *arg2 = 0 ;
41006
41007   arg1 = (Dali::PathConstrainer *)jarg1;
41008   arg2 = (Dali::Handle *)jarg2;
41009   if (!arg2) {
41010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41011     return ;
41012   }
41013   {
41014     try {
41015       (arg1)->Remove(*arg2);
41016     } catch (std::out_of_range& e) {
41017       {
41018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41019       };
41020     } catch (std::exception& e) {
41021       {
41022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41023       };
41024     } catch (...) {
41025       {
41026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41027       };
41028     }
41029   }
41030 }
41031
41032
41033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41034   int jresult ;
41035   Dali::FittingMode::Type result;
41036
41037   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41038   jresult = (int)result;
41039   return jresult;
41040 }
41041
41042
41043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41044   int jresult ;
41045   Dali::SamplingMode::Type result;
41046
41047   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41048   jresult = (int)result;
41049   return jresult;
41050 }
41051
41052
41053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41054   void * jresult ;
41055   Dali::BufferImage *result = 0 ;
41056
41057   {
41058     try {
41059       result = (Dali::BufferImage *)new Dali::BufferImage();
41060     } catch (std::out_of_range& e) {
41061       {
41062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41063       };
41064     } catch (std::exception& e) {
41065       {
41066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (...) {
41069       {
41070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41071       };
41072     }
41073   }
41074   jresult = (void *)result;
41075   return jresult;
41076 }
41077
41078
41079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41080   void * jresult ;
41081   unsigned int arg1 ;
41082   unsigned int arg2 ;
41083   Dali::Pixel::Format arg3 ;
41084   Dali::BufferImage result;
41085
41086   arg1 = (unsigned int)jarg1;
41087   arg2 = (unsigned int)jarg2;
41088   arg3 = (Dali::Pixel::Format)jarg3;
41089   {
41090     try {
41091       result = Dali::BufferImage::New(arg1,arg2,arg3);
41092     } catch (std::out_of_range& e) {
41093       {
41094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41095       };
41096     } catch (std::exception& e) {
41097       {
41098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (...) {
41101       {
41102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41103       };
41104     }
41105   }
41106   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41107   return jresult;
41108 }
41109
41110
41111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41112   void * jresult ;
41113   unsigned int arg1 ;
41114   unsigned int arg2 ;
41115   Dali::BufferImage result;
41116
41117   arg1 = (unsigned int)jarg1;
41118   arg2 = (unsigned int)jarg2;
41119   {
41120     try {
41121       result = Dali::BufferImage::New(arg1,arg2);
41122     } catch (std::out_of_range& e) {
41123       {
41124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41125       };
41126     } catch (std::exception& e) {
41127       {
41128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41129       };
41130     } catch (...) {
41131       {
41132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41133       };
41134     }
41135   }
41136   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41137   return jresult;
41138 }
41139
41140
41141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41142   void * jresult ;
41143   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41144   unsigned int arg2 ;
41145   unsigned int arg3 ;
41146   Dali::Pixel::Format arg4 ;
41147   unsigned int arg5 ;
41148   Dali::BufferImage result;
41149
41150   arg1 = jarg1;
41151   arg2 = (unsigned int)jarg2;
41152   arg3 = (unsigned int)jarg3;
41153   arg4 = (Dali::Pixel::Format)jarg4;
41154   arg5 = (unsigned int)jarg5;
41155   {
41156     try {
41157       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41158     } catch (std::out_of_range& e) {
41159       {
41160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41161       };
41162     } catch (std::exception& e) {
41163       {
41164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41165       };
41166     } catch (...) {
41167       {
41168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41169       };
41170     }
41171   }
41172   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41173
41174
41175   return jresult;
41176 }
41177
41178
41179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41180   void * jresult ;
41181   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41182   unsigned int arg2 ;
41183   unsigned int arg3 ;
41184   Dali::Pixel::Format arg4 ;
41185   Dali::BufferImage result;
41186
41187   arg1 = jarg1;
41188   arg2 = (unsigned int)jarg2;
41189   arg3 = (unsigned int)jarg3;
41190   arg4 = (Dali::Pixel::Format)jarg4;
41191   {
41192     try {
41193       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41194     } catch (std::out_of_range& e) {
41195       {
41196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41197       };
41198     } catch (std::exception& e) {
41199       {
41200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41205       };
41206     }
41207   }
41208   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41209
41210
41211   return jresult;
41212 }
41213
41214
41215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41216   void * jresult ;
41217   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41218   unsigned int arg2 ;
41219   unsigned int arg3 ;
41220   Dali::BufferImage result;
41221
41222   arg1 = jarg1;
41223   arg2 = (unsigned int)jarg2;
41224   arg3 = (unsigned int)jarg3;
41225   {
41226     try {
41227       result = Dali::BufferImage::New(arg1,arg2,arg3);
41228     } catch (std::out_of_range& e) {
41229       {
41230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41231       };
41232     } catch (std::exception& e) {
41233       {
41234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41235       };
41236     } catch (...) {
41237       {
41238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41239       };
41240     }
41241   }
41242   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41243
41244
41245   return jresult;
41246 }
41247
41248
41249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41250   void * jresult ;
41251   Dali::BaseHandle arg1 ;
41252   Dali::BaseHandle *argp1 ;
41253   Dali::BufferImage result;
41254
41255   argp1 = (Dali::BaseHandle *)jarg1;
41256   if (!argp1) {
41257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41258     return 0;
41259   }
41260   arg1 = *argp1;
41261   {
41262     try {
41263       result = Dali::BufferImage::DownCast(arg1);
41264     } catch (std::out_of_range& e) {
41265       {
41266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41267       };
41268     } catch (std::exception& e) {
41269       {
41270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41271       };
41272     } catch (...) {
41273       {
41274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41275       };
41276     }
41277   }
41278   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41279   return jresult;
41280 }
41281
41282
41283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41284   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41285
41286   arg1 = (Dali::BufferImage *)jarg1;
41287   {
41288     try {
41289       delete arg1;
41290     } catch (std::out_of_range& e) {
41291       {
41292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41293       };
41294     } catch (std::exception& e) {
41295       {
41296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41297       };
41298     } catch (...) {
41299       {
41300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41301       };
41302     }
41303   }
41304 }
41305
41306
41307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41308   void * jresult ;
41309   Dali::BufferImage *arg1 = 0 ;
41310   Dali::BufferImage *result = 0 ;
41311
41312   arg1 = (Dali::BufferImage *)jarg1;
41313   if (!arg1) {
41314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41315     return 0;
41316   }
41317   {
41318     try {
41319       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41320     } catch (std::out_of_range& e) {
41321       {
41322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (std::exception& e) {
41325       {
41326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41327       };
41328     } catch (...) {
41329       {
41330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41331       };
41332     }
41333   }
41334   jresult = (void *)result;
41335   return jresult;
41336 }
41337
41338
41339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41340   void * jresult ;
41341   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41342   Dali::BufferImage *arg2 = 0 ;
41343   Dali::BufferImage *result = 0 ;
41344
41345   arg1 = (Dali::BufferImage *)jarg1;
41346   arg2 = (Dali::BufferImage *)jarg2;
41347   if (!arg2) {
41348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41349     return 0;
41350   }
41351   {
41352     try {
41353       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41354     } catch (std::out_of_range& e) {
41355       {
41356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41357       };
41358     } catch (std::exception& e) {
41359       {
41360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41361       };
41362     } catch (...) {
41363       {
41364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41365       };
41366     }
41367   }
41368   jresult = (void *)result;
41369   return jresult;
41370 }
41371
41372
41373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41374   void * jresult ;
41375   Dali::BufferImage result;
41376
41377   {
41378     try {
41379       result = Dali::BufferImage::WHITE();
41380     } catch (std::out_of_range& e) {
41381       {
41382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (std::exception& e) {
41385       {
41386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41387       };
41388     } catch (...) {
41389       {
41390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41391       };
41392     }
41393   }
41394   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41395   return jresult;
41396 }
41397
41398
41399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41400   void * jresult ;
41401   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41402   Dali::PixelBuffer *result = 0 ;
41403
41404   arg1 = (Dali::BufferImage *)jarg1;
41405   {
41406     try {
41407       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41408     } catch (std::out_of_range& e) {
41409       {
41410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41411       };
41412     } catch (std::exception& e) {
41413       {
41414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41415       };
41416     } catch (...) {
41417       {
41418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41419       };
41420     }
41421   }
41422   jresult = (void *)result;
41423   return jresult;
41424 }
41425
41426
41427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41428   unsigned int jresult ;
41429   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41430   unsigned int result;
41431
41432   arg1 = (Dali::BufferImage *)jarg1;
41433   {
41434     try {
41435       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41436     } catch (std::out_of_range& e) {
41437       {
41438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (std::exception& e) {
41441       {
41442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41443       };
41444     } catch (...) {
41445       {
41446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41447       };
41448     }
41449   }
41450   jresult = result;
41451   return jresult;
41452 }
41453
41454
41455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41456   unsigned int jresult ;
41457   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41458   unsigned int result;
41459
41460   arg1 = (Dali::BufferImage *)jarg1;
41461   {
41462     try {
41463       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41464     } catch (std::out_of_range& e) {
41465       {
41466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41467       };
41468     } catch (std::exception& e) {
41469       {
41470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (...) {
41473       {
41474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41475       };
41476     }
41477   }
41478   jresult = result;
41479   return jresult;
41480 }
41481
41482
41483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41484   int jresult ;
41485   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41486   Dali::Pixel::Format result;
41487
41488   arg1 = (Dali::BufferImage *)jarg1;
41489   {
41490     try {
41491       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41492     } catch (std::out_of_range& e) {
41493       {
41494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41495       };
41496     } catch (std::exception& e) {
41497       {
41498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (...) {
41501       {
41502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41503       };
41504     }
41505   }
41506   jresult = (int)result;
41507   return jresult;
41508 }
41509
41510
41511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41512   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41513
41514   arg1 = (Dali::BufferImage *)jarg1;
41515   {
41516     try {
41517       (arg1)->Update();
41518     } catch (std::out_of_range& e) {
41519       {
41520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41521       };
41522     } catch (std::exception& e) {
41523       {
41524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41525       };
41526     } catch (...) {
41527       {
41528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41529       };
41530     }
41531   }
41532 }
41533
41534
41535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41536   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41537   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41538   Dali::RectArea *argp2 ;
41539
41540   arg1 = (Dali::BufferImage *)jarg1;
41541   argp2 = (Dali::RectArea *)jarg2;
41542   if (!argp2) {
41543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41544     return ;
41545   }
41546   arg2 = *argp2;
41547   {
41548     try {
41549       (arg1)->Update(arg2);
41550     } catch (std::out_of_range& e) {
41551       {
41552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41553       };
41554     } catch (std::exception& e) {
41555       {
41556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41557       };
41558     } catch (...) {
41559       {
41560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41561       };
41562     }
41563   }
41564 }
41565
41566
41567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41568   unsigned int jresult ;
41569   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41570   bool result;
41571
41572   arg1 = (Dali::BufferImage *)jarg1;
41573   {
41574     try {
41575       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41576     } catch (std::out_of_range& e) {
41577       {
41578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41579       };
41580     } catch (std::exception& e) {
41581       {
41582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41583       };
41584     } catch (...) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41587       };
41588     }
41589   }
41590   jresult = result;
41591   return jresult;
41592 }
41593
41594
41595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41596   void * jresult ;
41597   Dali::EncodedBufferImage *result = 0 ;
41598
41599   {
41600     try {
41601       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41602     } catch (std::out_of_range& e) {
41603       {
41604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41605       };
41606     } catch (std::exception& e) {
41607       {
41608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41609       };
41610     } catch (...) {
41611       {
41612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41613       };
41614     }
41615   }
41616   jresult = (void *)result;
41617   return jresult;
41618 }
41619
41620
41621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41622   void * jresult ;
41623   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41624   std::size_t arg2 ;
41625   Dali::EncodedBufferImage result;
41626
41627   arg1 = (uint8_t *)jarg1;
41628   arg2 = (std::size_t)jarg2;
41629   {
41630     try {
41631       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41632     } catch (std::out_of_range& e) {
41633       {
41634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41635       };
41636     } catch (std::exception& e) {
41637       {
41638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41639       };
41640     } catch (...) {
41641       {
41642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41643       };
41644     }
41645   }
41646   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41647   return jresult;
41648 }
41649
41650
41651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41652   void * jresult ;
41653   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41654   std::size_t arg2 ;
41655   Dali::ImageDimensions arg3 ;
41656   Dali::FittingMode::Type arg4 ;
41657   Dali::SamplingMode::Type arg5 ;
41658   bool arg6 ;
41659   Dali::ImageDimensions *argp3 ;
41660   Dali::EncodedBufferImage result;
41661
41662   arg1 = (uint8_t *)jarg1;
41663   arg2 = (std::size_t)jarg2;
41664   argp3 = (Dali::ImageDimensions *)jarg3;
41665   if (!argp3) {
41666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41667     return 0;
41668   }
41669   arg3 = *argp3;
41670   arg4 = (Dali::FittingMode::Type)jarg4;
41671   arg5 = (Dali::SamplingMode::Type)jarg5;
41672   arg6 = jarg6 ? true : false;
41673   {
41674     try {
41675       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41676     } catch (std::out_of_range& e) {
41677       {
41678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41679       };
41680     } catch (std::exception& e) {
41681       {
41682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41683       };
41684     } catch (...) {
41685       {
41686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41687       };
41688     }
41689   }
41690   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41691   return jresult;
41692 }
41693
41694
41695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41696   void * jresult ;
41697   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41698   std::size_t arg2 ;
41699   Dali::ImageDimensions arg3 ;
41700   Dali::FittingMode::Type arg4 ;
41701   Dali::SamplingMode::Type arg5 ;
41702   Dali::ImageDimensions *argp3 ;
41703   Dali::EncodedBufferImage result;
41704
41705   arg1 = (uint8_t *)jarg1;
41706   arg2 = (std::size_t)jarg2;
41707   argp3 = (Dali::ImageDimensions *)jarg3;
41708   if (!argp3) {
41709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41710     return 0;
41711   }
41712   arg3 = *argp3;
41713   arg4 = (Dali::FittingMode::Type)jarg4;
41714   arg5 = (Dali::SamplingMode::Type)jarg5;
41715   {
41716     try {
41717       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41718     } catch (std::out_of_range& e) {
41719       {
41720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41721       };
41722     } catch (std::exception& e) {
41723       {
41724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (...) {
41727       {
41728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41729       };
41730     }
41731   }
41732   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41733   return jresult;
41734 }
41735
41736
41737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41738   void * jresult ;
41739   Dali::BaseHandle arg1 ;
41740   Dali::BaseHandle *argp1 ;
41741   Dali::EncodedBufferImage result;
41742
41743   argp1 = (Dali::BaseHandle *)jarg1;
41744   if (!argp1) {
41745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41746     return 0;
41747   }
41748   arg1 = *argp1;
41749   {
41750     try {
41751       result = Dali::EncodedBufferImage::DownCast(arg1);
41752     } catch (std::out_of_range& e) {
41753       {
41754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41755       };
41756     } catch (std::exception& e) {
41757       {
41758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (...) {
41761       {
41762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41763       };
41764     }
41765   }
41766   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41767   return jresult;
41768 }
41769
41770
41771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41772   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41773
41774   arg1 = (Dali::EncodedBufferImage *)jarg1;
41775   {
41776     try {
41777       delete arg1;
41778     } catch (std::out_of_range& e) {
41779       {
41780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41781       };
41782     } catch (std::exception& e) {
41783       {
41784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41785       };
41786     } catch (...) {
41787       {
41788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41789       };
41790     }
41791   }
41792 }
41793
41794
41795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41796   void * jresult ;
41797   Dali::EncodedBufferImage *arg1 = 0 ;
41798   Dali::EncodedBufferImage *result = 0 ;
41799
41800   arg1 = (Dali::EncodedBufferImage *)jarg1;
41801   if (!arg1) {
41802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41803     return 0;
41804   }
41805   {
41806     try {
41807       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41808     } catch (std::out_of_range& e) {
41809       {
41810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41811       };
41812     } catch (std::exception& e) {
41813       {
41814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41815       };
41816     } catch (...) {
41817       {
41818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41819       };
41820     }
41821   }
41822   jresult = (void *)result;
41823   return jresult;
41824 }
41825
41826
41827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41828   void * jresult ;
41829   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41830   Dali::EncodedBufferImage *arg2 = 0 ;
41831   Dali::EncodedBufferImage *result = 0 ;
41832
41833   arg1 = (Dali::EncodedBufferImage *)jarg1;
41834   arg2 = (Dali::EncodedBufferImage *)jarg2;
41835   if (!arg2) {
41836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41837     return 0;
41838   }
41839   {
41840     try {
41841       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41842     } catch (std::out_of_range& e) {
41843       {
41844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41845       };
41846     } catch (std::exception& e) {
41847       {
41848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41849       };
41850     } catch (...) {
41851       {
41852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41853       };
41854     }
41855   }
41856   jresult = (void *)result;
41857   return jresult;
41858 }
41859
41860
41861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41862   void * jresult ;
41863   Dali::NativeImage *result = 0 ;
41864
41865   {
41866     try {
41867       result = (Dali::NativeImage *)new Dali::NativeImage();
41868     } catch (std::out_of_range& e) {
41869       {
41870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (std::exception& e) {
41873       {
41874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41875       };
41876     } catch (...) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41879       };
41880     }
41881   }
41882   jresult = (void *)result;
41883   return jresult;
41884 }
41885
41886
41887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41888   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41889
41890   arg1 = (Dali::NativeImage *)jarg1;
41891   {
41892     try {
41893       delete arg1;
41894     } catch (std::out_of_range& e) {
41895       {
41896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41897       };
41898     } catch (std::exception& e) {
41899       {
41900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41901       };
41902     } catch (...) {
41903       {
41904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41905       };
41906     }
41907   }
41908 }
41909
41910
41911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41912   void * jresult ;
41913   Dali::NativeImage *arg1 = 0 ;
41914   Dali::NativeImage *result = 0 ;
41915
41916   arg1 = (Dali::NativeImage *)jarg1;
41917   if (!arg1) {
41918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41919     return 0;
41920   }
41921   {
41922     try {
41923       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41924     } catch (std::out_of_range& e) {
41925       {
41926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41927       };
41928     } catch (std::exception& e) {
41929       {
41930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41931       };
41932     } catch (...) {
41933       {
41934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41935       };
41936     }
41937   }
41938   jresult = (void *)result;
41939   return jresult;
41940 }
41941
41942
41943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41944   void * jresult ;
41945   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41946   Dali::NativeImage *arg2 = 0 ;
41947   Dali::NativeImage *result = 0 ;
41948
41949   arg1 = (Dali::NativeImage *)jarg1;
41950   arg2 = (Dali::NativeImage *)jarg2;
41951   if (!arg2) {
41952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41953     return 0;
41954   }
41955   {
41956     try {
41957       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41958     } catch (std::out_of_range& e) {
41959       {
41960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41961       };
41962     } catch (std::exception& e) {
41963       {
41964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41965       };
41966     } catch (...) {
41967       {
41968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41969       };
41970     }
41971   }
41972   jresult = (void *)result;
41973   return jresult;
41974 }
41975
41976
41977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41978   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41979
41980   arg1 = (Dali::NativeImage *)jarg1;
41981   {
41982     try {
41983       (arg1)->CreateGlTexture();
41984     } catch (std::out_of_range& e) {
41985       {
41986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41987       };
41988     } catch (std::exception& e) {
41989       {
41990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41991       };
41992     } catch (...) {
41993       {
41994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41995       };
41996     }
41997   }
41998 }
41999
42000
42001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42002   void * jresult ;
42003   NativeImageInterface *arg1 = 0 ;
42004   Dali::NativeImage result;
42005
42006   arg1 = (NativeImageInterface *)jarg1;
42007   if (!arg1) {
42008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42009     return 0;
42010   }
42011   {
42012     try {
42013       result = Dali::NativeImage::New(*arg1);
42014     } catch (std::out_of_range& e) {
42015       {
42016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42017       };
42018     } catch (std::exception& e) {
42019       {
42020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42021       };
42022     } catch (...) {
42023       {
42024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42025       };
42026     }
42027   }
42028   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42029   return jresult;
42030 }
42031
42032
42033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42034   void * jresult ;
42035   Dali::BaseHandle arg1 ;
42036   Dali::BaseHandle *argp1 ;
42037   Dali::NativeImage result;
42038
42039   argp1 = (Dali::BaseHandle *)jarg1;
42040   if (!argp1) {
42041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42042     return 0;
42043   }
42044   arg1 = *argp1;
42045   {
42046     try {
42047       result = Dali::NativeImage::DownCast(arg1);
42048     } catch (std::out_of_range& e) {
42049       {
42050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42051       };
42052     } catch (std::exception& e) {
42053       {
42054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42055       };
42056     } catch (...) {
42057       {
42058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42059       };
42060     }
42061   }
42062   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42068   char * jresult ;
42069   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42070   char *result = 0 ;
42071
42072   arg1 = (Dali::NativeImage *)jarg1;
42073   {
42074     try {
42075       result = (char *)(arg1)->GetCustomFragmentPreFix();
42076     } catch (std::out_of_range& e) {
42077       {
42078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42079       };
42080     } catch (std::exception& e) {
42081       {
42082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42083       };
42084     } catch (...) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42087       };
42088     }
42089   }
42090   jresult = SWIG_csharp_string_callback((const char *)result);
42091   return jresult;
42092 }
42093
42094
42095 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42096   char * jresult ;
42097   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42098   char *result = 0 ;
42099
42100   arg1 = (Dali::NativeImage *)jarg1;
42101   {
42102     try {
42103       result = (char *)(arg1)->GetCustomSamplerTypename();
42104     } catch (std::out_of_range& e) {
42105       {
42106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (std::exception& e) {
42109       {
42110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42111       };
42112     } catch (...) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42115       };
42116     }
42117   }
42118   jresult = SWIG_csharp_string_callback((const char *)result);
42119   return jresult;
42120 }
42121
42122
42123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42124   unsigned int jresult ;
42125   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42126   bool result;
42127
42128   arg1 = (Dali::NativeImageInterface *)jarg1;
42129   {
42130     try {
42131       result = (bool)(arg1)->GlExtensionCreate();
42132     } catch (std::out_of_range& e) {
42133       {
42134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42135       };
42136     } catch (std::exception& e) {
42137       {
42138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42139       };
42140     } catch (...) {
42141       {
42142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42143       };
42144     }
42145   }
42146   jresult = result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42152   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42153
42154   arg1 = (Dali::NativeImageInterface *)jarg1;
42155   {
42156     try {
42157       (arg1)->GlExtensionDestroy();
42158     } catch (std::out_of_range& e) {
42159       {
42160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42161       };
42162     } catch (std::exception& e) {
42163       {
42164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (...) {
42167       {
42168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42169       };
42170     }
42171   }
42172 }
42173
42174
42175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42176   unsigned int jresult ;
42177   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42178   unsigned int result;
42179
42180   arg1 = (Dali::NativeImageInterface *)jarg1;
42181   {
42182     try {
42183       result = (unsigned int)(arg1)->TargetTexture();
42184     } catch (std::out_of_range& e) {
42185       {
42186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42187       };
42188     } catch (std::exception& e) {
42189       {
42190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42191       };
42192     } catch (...) {
42193       {
42194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42195       };
42196     }
42197   }
42198   jresult = result;
42199   return jresult;
42200 }
42201
42202
42203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42204   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42205
42206   arg1 = (Dali::NativeImageInterface *)jarg1;
42207   {
42208     try {
42209       (arg1)->PrepareTexture();
42210     } catch (std::out_of_range& e) {
42211       {
42212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42213       };
42214     } catch (std::exception& e) {
42215       {
42216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42217       };
42218     } catch (...) {
42219       {
42220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42221       };
42222     }
42223   }
42224 }
42225
42226
42227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42228   unsigned int jresult ;
42229   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42230   unsigned int result;
42231
42232   arg1 = (Dali::NativeImageInterface *)jarg1;
42233   {
42234     try {
42235       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42236     } catch (std::out_of_range& e) {
42237       {
42238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42239       };
42240     } catch (std::exception& e) {
42241       {
42242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42243       };
42244     } catch (...) {
42245       {
42246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42247       };
42248     }
42249   }
42250   jresult = result;
42251   return jresult;
42252 }
42253
42254
42255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42256   unsigned int jresult ;
42257   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42258   unsigned int result;
42259
42260   arg1 = (Dali::NativeImageInterface *)jarg1;
42261   {
42262     try {
42263       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42264     } catch (std::out_of_range& e) {
42265       {
42266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42267       };
42268     } catch (std::exception& e) {
42269       {
42270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42271       };
42272     } catch (...) {
42273       {
42274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42275       };
42276     }
42277   }
42278   jresult = result;
42279   return jresult;
42280 }
42281
42282
42283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42284   unsigned int jresult ;
42285   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42286   bool result;
42287
42288   arg1 = (Dali::NativeImageInterface *)jarg1;
42289   {
42290     try {
42291       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42292     } catch (std::out_of_range& e) {
42293       {
42294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42295       };
42296     } catch (std::exception& e) {
42297       {
42298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42299       };
42300     } catch (...) {
42301       {
42302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42303       };
42304     }
42305   }
42306   jresult = result;
42307   return jresult;
42308 }
42309
42310
42311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42312   void * jresult ;
42313   std::string *arg1 = 0 ;
42314   Dali::ImageDimensions result;
42315
42316   if (!jarg1) {
42317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42318     return 0;
42319   }
42320   std::string arg1_str(jarg1);
42321   arg1 = &arg1_str;
42322   {
42323     try {
42324       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42325     } catch (std::out_of_range& e) {
42326       {
42327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42328       };
42329     } catch (std::exception& e) {
42330       {
42331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42332       };
42333     } catch (...) {
42334       {
42335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42336       };
42337     }
42338   }
42339   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42340
42341   //argout typemap for const std::string&
42342
42343   return jresult;
42344 }
42345
42346
42347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42348   void * jresult ;
42349   Dali::ResourceImage *result = 0 ;
42350
42351   {
42352     try {
42353       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42354     } catch (std::out_of_range& e) {
42355       {
42356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42357       };
42358     } catch (std::exception& e) {
42359       {
42360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42361       };
42362     } catch (...) {
42363       {
42364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42365       };
42366     }
42367   }
42368   jresult = (void *)result;
42369   return jresult;
42370 }
42371
42372
42373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42374   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42375
42376   arg1 = (Dali::ResourceImage *)jarg1;
42377   {
42378     try {
42379       delete arg1;
42380     } catch (std::out_of_range& e) {
42381       {
42382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42383       };
42384     } catch (std::exception& e) {
42385       {
42386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42391       };
42392     }
42393   }
42394 }
42395
42396
42397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42398   void * jresult ;
42399   Dali::ResourceImage *arg1 = 0 ;
42400   Dali::ResourceImage *result = 0 ;
42401
42402   arg1 = (Dali::ResourceImage *)jarg1;
42403   if (!arg1) {
42404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42405     return 0;
42406   }
42407   {
42408     try {
42409       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42410     } catch (std::out_of_range& e) {
42411       {
42412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (std::exception& e) {
42415       {
42416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (...) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42421       };
42422     }
42423   }
42424   jresult = (void *)result;
42425   return jresult;
42426 }
42427
42428
42429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42430   void * jresult ;
42431   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42432   Dali::ResourceImage *arg2 = 0 ;
42433   Dali::ResourceImage *result = 0 ;
42434
42435   arg1 = (Dali::ResourceImage *)jarg1;
42436   arg2 = (Dali::ResourceImage *)jarg2;
42437   if (!arg2) {
42438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42439     return 0;
42440   }
42441   {
42442     try {
42443       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42444     } catch (std::out_of_range& e) {
42445       {
42446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42447       };
42448     } catch (std::exception& e) {
42449       {
42450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (...) {
42453       {
42454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42455       };
42456     }
42457   }
42458   jresult = (void *)result;
42459   return jresult;
42460 }
42461
42462
42463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42464   void * jresult ;
42465   std::string *arg1 = 0 ;
42466   bool arg2 ;
42467   Dali::ResourceImage result;
42468
42469   if (!jarg1) {
42470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42471     return 0;
42472   }
42473   std::string arg1_str(jarg1);
42474   arg1 = &arg1_str;
42475   arg2 = jarg2 ? true : false;
42476   {
42477     try {
42478       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42479     } catch (std::out_of_range& e) {
42480       {
42481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42482       };
42483     } catch (std::exception& e) {
42484       {
42485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (...) {
42488       {
42489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42490       };
42491     }
42492   }
42493   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42494
42495   //argout typemap for const std::string&
42496
42497   return jresult;
42498 }
42499
42500
42501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42502   void * jresult ;
42503   std::string *arg1 = 0 ;
42504   Dali::ResourceImage result;
42505
42506   if (!jarg1) {
42507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42508     return 0;
42509   }
42510   std::string arg1_str(jarg1);
42511   arg1 = &arg1_str;
42512   {
42513     try {
42514       result = Dali::ResourceImage::New((std::string const &)*arg1);
42515     } catch (std::out_of_range& e) {
42516       {
42517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42518       };
42519     } catch (std::exception& e) {
42520       {
42521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (...) {
42524       {
42525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42526       };
42527     }
42528   }
42529   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42530
42531   //argout typemap for const std::string&
42532
42533   return jresult;
42534 }
42535
42536
42537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42538   void * jresult ;
42539   std::string *arg1 = 0 ;
42540   Dali::ImageDimensions arg2 ;
42541   Dali::FittingMode::Type arg3 ;
42542   Dali::SamplingMode::Type arg4 ;
42543   bool arg5 ;
42544   Dali::ImageDimensions *argp2 ;
42545   Dali::ResourceImage result;
42546
42547   if (!jarg1) {
42548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42549     return 0;
42550   }
42551   std::string arg1_str(jarg1);
42552   arg1 = &arg1_str;
42553   argp2 = (Dali::ImageDimensions *)jarg2;
42554   if (!argp2) {
42555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42556     return 0;
42557   }
42558   arg2 = *argp2;
42559   arg3 = (Dali::FittingMode::Type)jarg3;
42560   arg4 = (Dali::SamplingMode::Type)jarg4;
42561   arg5 = jarg5 ? true : false;
42562   {
42563     try {
42564       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42565     } catch (std::out_of_range& e) {
42566       {
42567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42568       };
42569     } catch (std::exception& e) {
42570       {
42571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42572       };
42573     } catch (...) {
42574       {
42575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42576       };
42577     }
42578   }
42579   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42580
42581   //argout typemap for const std::string&
42582
42583   return jresult;
42584 }
42585
42586
42587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42588   void * jresult ;
42589   std::string *arg1 = 0 ;
42590   Dali::ImageDimensions arg2 ;
42591   Dali::FittingMode::Type arg3 ;
42592   Dali::SamplingMode::Type arg4 ;
42593   Dali::ImageDimensions *argp2 ;
42594   Dali::ResourceImage result;
42595
42596   if (!jarg1) {
42597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42598     return 0;
42599   }
42600   std::string arg1_str(jarg1);
42601   arg1 = &arg1_str;
42602   argp2 = (Dali::ImageDimensions *)jarg2;
42603   if (!argp2) {
42604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42605     return 0;
42606   }
42607   arg2 = *argp2;
42608   arg3 = (Dali::FittingMode::Type)jarg3;
42609   arg4 = (Dali::SamplingMode::Type)jarg4;
42610   {
42611     try {
42612       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42613     } catch (std::out_of_range& e) {
42614       {
42615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42616       };
42617     } catch (std::exception& e) {
42618       {
42619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42620       };
42621     } catch (...) {
42622       {
42623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42624       };
42625     }
42626   }
42627   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42628
42629   //argout typemap for const std::string&
42630
42631   return jresult;
42632 }
42633
42634
42635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42636   void * jresult ;
42637   std::string *arg1 = 0 ;
42638   Dali::ImageDimensions arg2 ;
42639   Dali::FittingMode::Type arg3 ;
42640   Dali::ImageDimensions *argp2 ;
42641   Dali::ResourceImage result;
42642
42643   if (!jarg1) {
42644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42645     return 0;
42646   }
42647   std::string arg1_str(jarg1);
42648   arg1 = &arg1_str;
42649   argp2 = (Dali::ImageDimensions *)jarg2;
42650   if (!argp2) {
42651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42652     return 0;
42653   }
42654   arg2 = *argp2;
42655   arg3 = (Dali::FittingMode::Type)jarg3;
42656   {
42657     try {
42658       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42659     } catch (std::out_of_range& e) {
42660       {
42661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (std::exception& e) {
42664       {
42665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (...) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42670       };
42671     }
42672   }
42673   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42674
42675   //argout typemap for const std::string&
42676
42677   return jresult;
42678 }
42679
42680
42681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42682   void * jresult ;
42683   std::string *arg1 = 0 ;
42684   Dali::ImageDimensions arg2 ;
42685   Dali::ImageDimensions *argp2 ;
42686   Dali::ResourceImage result;
42687
42688   if (!jarg1) {
42689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42690     return 0;
42691   }
42692   std::string arg1_str(jarg1);
42693   arg1 = &arg1_str;
42694   argp2 = (Dali::ImageDimensions *)jarg2;
42695   if (!argp2) {
42696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42697     return 0;
42698   }
42699   arg2 = *argp2;
42700   {
42701     try {
42702       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42703     } catch (std::out_of_range& e) {
42704       {
42705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42706       };
42707     } catch (std::exception& e) {
42708       {
42709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42710       };
42711     } catch (...) {
42712       {
42713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42714       };
42715     }
42716   }
42717   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42718
42719   //argout typemap for const std::string&
42720
42721   return jresult;
42722 }
42723
42724
42725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42726   void * jresult ;
42727   Dali::BaseHandle arg1 ;
42728   Dali::BaseHandle *argp1 ;
42729   Dali::ResourceImage result;
42730
42731   argp1 = (Dali::BaseHandle *)jarg1;
42732   if (!argp1) {
42733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42734     return 0;
42735   }
42736   arg1 = *argp1;
42737   {
42738     try {
42739       result = Dali::ResourceImage::DownCast(arg1);
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42755   return jresult;
42756 }
42757
42758
42759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42760   int jresult ;
42761   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42762   Dali::LoadingState result;
42763
42764   arg1 = (Dali::ResourceImage *)jarg1;
42765   {
42766     try {
42767       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42768     } catch (std::out_of_range& e) {
42769       {
42770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42771       };
42772     } catch (std::exception& e) {
42773       {
42774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42775       };
42776     } catch (...) {
42777       {
42778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42779       };
42780     }
42781   }
42782   jresult = (int)result;
42783   return jresult;
42784 }
42785
42786
42787 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42788   char * jresult ;
42789   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42790   std::string result;
42791
42792   arg1 = (Dali::ResourceImage *)jarg1;
42793   {
42794     try {
42795       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42796     } catch (std::out_of_range& e) {
42797       {
42798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42799       };
42800     } catch (std::exception& e) {
42801       {
42802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42803       };
42804     } catch (...) {
42805       {
42806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42807       };
42808     }
42809   }
42810   jresult = SWIG_csharp_string_callback((&result)->c_str());
42811   return jresult;
42812 }
42813
42814
42815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42816   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42817
42818   arg1 = (Dali::ResourceImage *)jarg1;
42819   {
42820     try {
42821       (arg1)->Reload();
42822     } catch (std::out_of_range& e) {
42823       {
42824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42825       };
42826     } catch (std::exception& e) {
42827       {
42828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42829       };
42830     } catch (...) {
42831       {
42832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42833       };
42834     }
42835   }
42836 }
42837
42838
42839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42840   void * jresult ;
42841   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42842   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42843
42844   arg1 = (Dali::ResourceImage *)jarg1;
42845   {
42846     try {
42847       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862   jresult = (void *)result;
42863   return jresult;
42864 }
42865
42866
42867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42868   void * jresult ;
42869   Dali::FrameBufferImage *result = 0 ;
42870
42871   {
42872     try {
42873       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42874     } catch (std::out_of_range& e) {
42875       {
42876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42877       };
42878     } catch (std::exception& e) {
42879       {
42880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (...) {
42883       {
42884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42885       };
42886     }
42887   }
42888   jresult = (void *)result;
42889   return jresult;
42890 }
42891
42892
42893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42894   void * jresult ;
42895   unsigned int arg1 ;
42896   unsigned int arg2 ;
42897   Dali::Pixel::Format arg3 ;
42898   Dali::RenderBuffer::Format arg4 ;
42899   Dali::FrameBufferImage result;
42900
42901   arg1 = (unsigned int)jarg1;
42902   arg2 = (unsigned int)jarg2;
42903   arg3 = (Dali::Pixel::Format)jarg3;
42904   arg4 = (Dali::RenderBuffer::Format)jarg4;
42905   {
42906     try {
42907       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42908     } catch (std::out_of_range& e) {
42909       {
42910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42911       };
42912     } catch (std::exception& e) {
42913       {
42914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42915       };
42916     } catch (...) {
42917       {
42918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42919       };
42920     }
42921   }
42922   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42923   return jresult;
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42928   void * jresult ;
42929   unsigned int arg1 ;
42930   unsigned int arg2 ;
42931   Dali::Pixel::Format arg3 ;
42932   Dali::FrameBufferImage result;
42933
42934   arg1 = (unsigned int)jarg1;
42935   arg2 = (unsigned int)jarg2;
42936   arg3 = (Dali::Pixel::Format)jarg3;
42937   {
42938     try {
42939       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42940     } catch (std::out_of_range& e) {
42941       {
42942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42943       };
42944     } catch (std::exception& e) {
42945       {
42946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42951       };
42952     }
42953   }
42954   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42955   return jresult;
42956 }
42957
42958
42959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42960   void * jresult ;
42961   unsigned int arg1 ;
42962   unsigned int arg2 ;
42963   Dali::FrameBufferImage result;
42964
42965   arg1 = (unsigned int)jarg1;
42966   arg2 = (unsigned int)jarg2;
42967   {
42968     try {
42969       result = Dali::FrameBufferImage::New(arg1,arg2);
42970     } catch (std::out_of_range& e) {
42971       {
42972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42973       };
42974     } catch (std::exception& e) {
42975       {
42976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (...) {
42979       {
42980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42981       };
42982     }
42983   }
42984   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42985   return jresult;
42986 }
42987
42988
42989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42990   void * jresult ;
42991   unsigned int arg1 ;
42992   Dali::FrameBufferImage result;
42993
42994   arg1 = (unsigned int)jarg1;
42995   {
42996     try {
42997       result = Dali::FrameBufferImage::New(arg1);
42998     } catch (std::out_of_range& e) {
42999       {
43000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43001       };
43002     } catch (std::exception& e) {
43003       {
43004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43005       };
43006     } catch (...) {
43007       {
43008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43009       };
43010     }
43011   }
43012   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43013   return jresult;
43014 }
43015
43016
43017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43018   void * jresult ;
43019   Dali::FrameBufferImage result;
43020
43021   {
43022     try {
43023       result = Dali::FrameBufferImage::New();
43024     } catch (std::out_of_range& e) {
43025       {
43026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43027       };
43028     } catch (std::exception& e) {
43029       {
43030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43031       };
43032     } catch (...) {
43033       {
43034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43035       };
43036     }
43037   }
43038   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43044   void * jresult ;
43045   Dali::NativeImageInterface *arg1 = 0 ;
43046   Dali::FrameBufferImage result;
43047
43048   arg1 = (Dali::NativeImageInterface *)jarg1;
43049   if (!arg1) {
43050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43051     return 0;
43052   }
43053   {
43054     try {
43055       result = Dali::FrameBufferImage::New(*arg1);
43056     } catch (std::out_of_range& e) {
43057       {
43058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (std::exception& e) {
43061       {
43062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43063       };
43064     } catch (...) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43067       };
43068     }
43069   }
43070   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43071   return jresult;
43072 }
43073
43074
43075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43076   void * jresult ;
43077   Dali::BaseHandle arg1 ;
43078   Dali::BaseHandle *argp1 ;
43079   Dali::FrameBufferImage result;
43080
43081   argp1 = (Dali::BaseHandle *)jarg1;
43082   if (!argp1) {
43083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43084     return 0;
43085   }
43086   arg1 = *argp1;
43087   {
43088     try {
43089       result = Dali::FrameBufferImage::DownCast(arg1);
43090     } catch (std::out_of_range& e) {
43091       {
43092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (std::exception& e) {
43095       {
43096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43101       };
43102     }
43103   }
43104   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43105   return jresult;
43106 }
43107
43108
43109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43110   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43111
43112   arg1 = (Dali::FrameBufferImage *)jarg1;
43113   {
43114     try {
43115       delete arg1;
43116     } catch (std::out_of_range& e) {
43117       {
43118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43119       };
43120     } catch (std::exception& e) {
43121       {
43122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43123       };
43124     } catch (...) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43127       };
43128     }
43129   }
43130 }
43131
43132
43133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43134   void * jresult ;
43135   Dali::FrameBufferImage *arg1 = 0 ;
43136   Dali::FrameBufferImage *result = 0 ;
43137
43138   arg1 = (Dali::FrameBufferImage *)jarg1;
43139   if (!arg1) {
43140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43141     return 0;
43142   }
43143   {
43144     try {
43145       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43146     } catch (std::out_of_range& e) {
43147       {
43148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43149       };
43150     } catch (std::exception& e) {
43151       {
43152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43153       };
43154     } catch (...) {
43155       {
43156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43157       };
43158     }
43159   }
43160   jresult = (void *)result;
43161   return jresult;
43162 }
43163
43164
43165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43166   void * jresult ;
43167   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43168   Dali::FrameBufferImage *arg2 = 0 ;
43169   Dali::FrameBufferImage *result = 0 ;
43170
43171   arg1 = (Dali::FrameBufferImage *)jarg1;
43172   arg2 = (Dali::FrameBufferImage *)jarg2;
43173   if (!arg2) {
43174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43175     return 0;
43176   }
43177   {
43178     try {
43179       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43180     } catch (std::out_of_range& e) {
43181       {
43182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (std::exception& e) {
43185       {
43186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (...) {
43189       {
43190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43191       };
43192     }
43193   }
43194   jresult = (void *)result;
43195   return jresult;
43196 }
43197
43198
43199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43200   void * jresult ;
43201   Dali::NinePatchImage *result = 0 ;
43202
43203   {
43204     try {
43205       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43206     } catch (std::out_of_range& e) {
43207       {
43208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43209       };
43210     } catch (std::exception& e) {
43211       {
43212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43213       };
43214     } catch (...) {
43215       {
43216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43217       };
43218     }
43219   }
43220   jresult = (void *)result;
43221   return jresult;
43222 }
43223
43224
43225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43226   void * jresult ;
43227   std::string *arg1 = 0 ;
43228   Dali::NinePatchImage result;
43229
43230   if (!jarg1) {
43231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43232     return 0;
43233   }
43234   std::string arg1_str(jarg1);
43235   arg1 = &arg1_str;
43236   {
43237     try {
43238       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43239     } catch (std::out_of_range& e) {
43240       {
43241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43242       };
43243     } catch (std::exception& e) {
43244       {
43245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43246       };
43247     } catch (...) {
43248       {
43249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43250       };
43251     }
43252   }
43253   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43254
43255   //argout typemap for const std::string&
43256
43257   return jresult;
43258 }
43259
43260
43261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43262   void * jresult ;
43263   Dali::BaseHandle arg1 ;
43264   Dali::BaseHandle *argp1 ;
43265   Dali::NinePatchImage result;
43266
43267   argp1 = (Dali::BaseHandle *)jarg1;
43268   if (!argp1) {
43269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43270     return 0;
43271   }
43272   arg1 = *argp1;
43273   {
43274     try {
43275       result = Dali::NinePatchImage::DownCast(arg1);
43276     } catch (std::out_of_range& e) {
43277       {
43278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43279       };
43280     } catch (std::exception& e) {
43281       {
43282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43283       };
43284     } catch (...) {
43285       {
43286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43287       };
43288     }
43289   }
43290   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43296   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43297
43298   arg1 = (Dali::NinePatchImage *)jarg1;
43299   {
43300     try {
43301       delete arg1;
43302     } catch (std::out_of_range& e) {
43303       {
43304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (std::exception& e) {
43307       {
43308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43309       };
43310     } catch (...) {
43311       {
43312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43313       };
43314     }
43315   }
43316 }
43317
43318
43319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43320   void * jresult ;
43321   Dali::NinePatchImage *arg1 = 0 ;
43322   Dali::NinePatchImage *result = 0 ;
43323
43324   arg1 = (Dali::NinePatchImage *)jarg1;
43325   if (!arg1) {
43326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43327     return 0;
43328   }
43329   {
43330     try {
43331       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43332     } catch (std::out_of_range& e) {
43333       {
43334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43335       };
43336     } catch (std::exception& e) {
43337       {
43338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43339       };
43340     } catch (...) {
43341       {
43342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43343       };
43344     }
43345   }
43346   jresult = (void *)result;
43347   return jresult;
43348 }
43349
43350
43351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43352   void * jresult ;
43353   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43354   Dali::NinePatchImage *arg2 = 0 ;
43355   Dali::NinePatchImage *result = 0 ;
43356
43357   arg1 = (Dali::NinePatchImage *)jarg1;
43358   arg2 = (Dali::NinePatchImage *)jarg2;
43359   if (!arg2) {
43360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43361     return 0;
43362   }
43363   {
43364     try {
43365       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43366     } catch (std::out_of_range& e) {
43367       {
43368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43369       };
43370     } catch (std::exception& e) {
43371       {
43372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43373       };
43374     } catch (...) {
43375       {
43376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43377       };
43378     }
43379   }
43380   jresult = (void *)result;
43381   return jresult;
43382 }
43383
43384
43385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43386   void * jresult ;
43387   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43388   Dali::Vector4 result;
43389
43390   arg1 = (Dali::NinePatchImage *)jarg1;
43391   {
43392     try {
43393       result = (arg1)->GetStretchBorders();
43394     } catch (std::out_of_range& e) {
43395       {
43396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43397       };
43398     } catch (std::exception& e) {
43399       {
43400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43401       };
43402     } catch (...) {
43403       {
43404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43405       };
43406     }
43407   }
43408   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43409   return jresult;
43410 }
43411
43412
43413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43414   void * jresult ;
43415   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43416   Dali::NinePatchImage::StretchRanges *result = 0 ;
43417
43418   arg1 = (Dali::NinePatchImage *)jarg1;
43419   {
43420     try {
43421       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43422     } catch (std::out_of_range& e) {
43423       {
43424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43425       };
43426     } catch (std::exception& e) {
43427       {
43428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43429       };
43430     } catch (...) {
43431       {
43432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43433       };
43434     }
43435   }
43436   jresult = (void *)result;
43437   return jresult;
43438 }
43439
43440
43441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43442   void * jresult ;
43443   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43444   Dali::NinePatchImage::StretchRanges *result = 0 ;
43445
43446   arg1 = (Dali::NinePatchImage *)jarg1;
43447   {
43448     try {
43449       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43450     } catch (std::out_of_range& e) {
43451       {
43452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43453       };
43454     } catch (std::exception& e) {
43455       {
43456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43457       };
43458     } catch (...) {
43459       {
43460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43461       };
43462     }
43463   }
43464   jresult = (void *)result;
43465   return jresult;
43466 }
43467
43468
43469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43470   void * jresult ;
43471   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43472   Dali::Rect< int > result;
43473
43474   arg1 = (Dali::NinePatchImage *)jarg1;
43475   {
43476     try {
43477       result = (arg1)->GetChildRectangle();
43478     } catch (std::out_of_range& e) {
43479       {
43480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43481       };
43482     } catch (std::exception& e) {
43483       {
43484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43485       };
43486     } catch (...) {
43487       {
43488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43489       };
43490     }
43491   }
43492   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43493   return jresult;
43494 }
43495
43496
43497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43498   void * jresult ;
43499   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43500   Dali::BufferImage result;
43501
43502   arg1 = (Dali::NinePatchImage *)jarg1;
43503   {
43504     try {
43505       result = (arg1)->CreateCroppedBufferImage();
43506     } catch (std::out_of_range& e) {
43507       {
43508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43509       };
43510     } catch (std::exception& e) {
43511       {
43512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43513       };
43514     } catch (...) {
43515       {
43516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43517       };
43518     }
43519   }
43520   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43521   return jresult;
43522 }
43523
43524
43525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43526   unsigned int jresult ;
43527   std::string *arg1 = 0 ;
43528   bool result;
43529
43530   if (!jarg1) {
43531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43532     return 0;
43533   }
43534   std::string arg1_str(jarg1);
43535   arg1 = &arg1_str;
43536   {
43537     try {
43538       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43539     } catch (std::out_of_range& e) {
43540       {
43541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43542       };
43543     } catch (std::exception& e) {
43544       {
43545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43546       };
43547     } catch (...) {
43548       {
43549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43550       };
43551     }
43552   }
43553   jresult = result;
43554
43555   //argout typemap for const std::string&
43556
43557   return jresult;
43558 }
43559
43560
43561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43562   int jresult ;
43563   int result;
43564
43565   result = (int)Dali::CameraActor::Property::TYPE;
43566   jresult = (int)result;
43567   return jresult;
43568 }
43569
43570
43571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43572   int jresult ;
43573   int result;
43574
43575   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43576   jresult = (int)result;
43577   return jresult;
43578 }
43579
43580
43581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43582   int jresult ;
43583   int result;
43584
43585   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43586   jresult = (int)result;
43587   return jresult;
43588 }
43589
43590
43591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43592   int jresult ;
43593   int result;
43594
43595   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43596   jresult = (int)result;
43597   return jresult;
43598 }
43599
43600
43601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43602   int jresult ;
43603   int result;
43604
43605   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43606   jresult = (int)result;
43607   return jresult;
43608 }
43609
43610
43611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43612   int jresult ;
43613   int result;
43614
43615   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43616   jresult = (int)result;
43617   return jresult;
43618 }
43619
43620
43621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43622   int jresult ;
43623   int result;
43624
43625   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43626   jresult = (int)result;
43627   return jresult;
43628 }
43629
43630
43631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43632   int jresult ;
43633   int result;
43634
43635   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43636   jresult = (int)result;
43637   return jresult;
43638 }
43639
43640
43641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43642   int jresult ;
43643   int result;
43644
43645   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43646   jresult = (int)result;
43647   return jresult;
43648 }
43649
43650
43651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43652   int jresult ;
43653   int result;
43654
43655   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43656   jresult = (int)result;
43657   return jresult;
43658 }
43659
43660
43661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43662   int jresult ;
43663   int result;
43664
43665   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43666   jresult = (int)result;
43667   return jresult;
43668 }
43669
43670
43671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43672   int jresult ;
43673   int result;
43674
43675   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43676   jresult = (int)result;
43677   return jresult;
43678 }
43679
43680
43681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43682   int jresult ;
43683   int result;
43684
43685   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43686   jresult = (int)result;
43687   return jresult;
43688 }
43689
43690
43691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43692   int jresult ;
43693   int result;
43694
43695   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43696   jresult = (int)result;
43697   return jresult;
43698 }
43699
43700
43701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43702   void * jresult ;
43703   Dali::CameraActor::Property *result = 0 ;
43704
43705   {
43706     try {
43707       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43708     } catch (std::out_of_range& e) {
43709       {
43710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43711       };
43712     } catch (std::exception& e) {
43713       {
43714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43715       };
43716     } catch (...) {
43717       {
43718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43719       };
43720     }
43721   }
43722   jresult = (void *)result;
43723   return jresult;
43724 }
43725
43726
43727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43728   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43729
43730   arg1 = (Dali::CameraActor::Property *)jarg1;
43731   {
43732     try {
43733       delete arg1;
43734     } catch (std::out_of_range& e) {
43735       {
43736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43737       };
43738     } catch (std::exception& e) {
43739       {
43740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43741       };
43742     } catch (...) {
43743       {
43744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43745       };
43746     }
43747   }
43748 }
43749
43750
43751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43752   void * jresult ;
43753   Dali::CameraActor *result = 0 ;
43754
43755   {
43756     try {
43757       result = (Dali::CameraActor *)new Dali::CameraActor();
43758     } catch (std::out_of_range& e) {
43759       {
43760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43761       };
43762     } catch (std::exception& e) {
43763       {
43764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43765       };
43766     } catch (...) {
43767       {
43768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43769       };
43770     }
43771   }
43772   jresult = (void *)result;
43773   return jresult;
43774 }
43775
43776
43777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43778   void * jresult ;
43779   Dali::CameraActor result;
43780
43781   {
43782     try {
43783       result = Dali::CameraActor::New();
43784     } catch (std::out_of_range& e) {
43785       {
43786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43787       };
43788     } catch (std::exception& e) {
43789       {
43790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43791       };
43792     } catch (...) {
43793       {
43794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43795       };
43796     }
43797   }
43798   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43799   return jresult;
43800 }
43801
43802
43803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43804   void * jresult ;
43805   Dali::Size *arg1 = 0 ;
43806   Dali::CameraActor result;
43807
43808   arg1 = (Dali::Size *)jarg1;
43809   if (!arg1) {
43810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43811     return 0;
43812   }
43813   {
43814     try {
43815       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43816     } catch (std::out_of_range& e) {
43817       {
43818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43819       };
43820     } catch (std::exception& e) {
43821       {
43822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43823       };
43824     } catch (...) {
43825       {
43826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43827       };
43828     }
43829   }
43830   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43831   return jresult;
43832 }
43833
43834
43835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43836   void * jresult ;
43837   Dali::BaseHandle arg1 ;
43838   Dali::BaseHandle *argp1 ;
43839   Dali::CameraActor result;
43840
43841   argp1 = (Dali::BaseHandle *)jarg1;
43842   if (!argp1) {
43843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43844     return 0;
43845   }
43846   arg1 = *argp1;
43847   {
43848     try {
43849       result = Dali::CameraActor::DownCast(arg1);
43850     } catch (std::out_of_range& e) {
43851       {
43852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43853       };
43854     } catch (std::exception& e) {
43855       {
43856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43857       };
43858     } catch (...) {
43859       {
43860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43861       };
43862     }
43863   }
43864   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43870   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43871
43872   arg1 = (Dali::CameraActor *)jarg1;
43873   {
43874     try {
43875       delete arg1;
43876     } catch (std::out_of_range& e) {
43877       {
43878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43879       };
43880     } catch (std::exception& e) {
43881       {
43882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43883       };
43884     } catch (...) {
43885       {
43886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43887       };
43888     }
43889   }
43890 }
43891
43892
43893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43894   void * jresult ;
43895   Dali::CameraActor *arg1 = 0 ;
43896   Dali::CameraActor *result = 0 ;
43897
43898   arg1 = (Dali::CameraActor *)jarg1;
43899   if (!arg1) {
43900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43901     return 0;
43902   }
43903   {
43904     try {
43905       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43906     } catch (std::out_of_range& e) {
43907       {
43908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43909       };
43910     } catch (std::exception& e) {
43911       {
43912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43913       };
43914     } catch (...) {
43915       {
43916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43917       };
43918     }
43919   }
43920   jresult = (void *)result;
43921   return jresult;
43922 }
43923
43924
43925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43926   void * jresult ;
43927   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43928   Dali::CameraActor *arg2 = 0 ;
43929   Dali::CameraActor *result = 0 ;
43930
43931   arg1 = (Dali::CameraActor *)jarg1;
43932   arg2 = (Dali::CameraActor *)jarg2;
43933   if (!arg2) {
43934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43935     return 0;
43936   }
43937   {
43938     try {
43939       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43940     } catch (std::out_of_range& e) {
43941       {
43942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (std::exception& e) {
43945       {
43946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43947       };
43948     } catch (...) {
43949       {
43950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43951       };
43952     }
43953   }
43954   jresult = (void *)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43960   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43961   Dali::Camera::Type arg2 ;
43962
43963   arg1 = (Dali::CameraActor *)jarg1;
43964   arg2 = (Dali::Camera::Type)jarg2;
43965   {
43966     try {
43967       (arg1)->SetType(arg2);
43968     } catch (std::out_of_range& e) {
43969       {
43970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43971       };
43972     } catch (std::exception& e) {
43973       {
43974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43975       };
43976     } catch (...) {
43977       {
43978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43979       };
43980     }
43981   }
43982 }
43983
43984
43985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43986   int jresult ;
43987   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43988   Dali::Camera::Type result;
43989
43990   arg1 = (Dali::CameraActor *)jarg1;
43991   {
43992     try {
43993       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43994     } catch (std::out_of_range& e) {
43995       {
43996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43997       };
43998     } catch (std::exception& e) {
43999       {
44000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (...) {
44003       {
44004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44005       };
44006     }
44007   }
44008   jresult = (int)result;
44009   return jresult;
44010 }
44011
44012
44013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44014   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44015   Dali::Camera::ProjectionMode arg2 ;
44016
44017   arg1 = (Dali::CameraActor *)jarg1;
44018   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44019   {
44020     try {
44021       (arg1)->SetProjectionMode(arg2);
44022     } catch (std::out_of_range& e) {
44023       {
44024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44025       };
44026     } catch (std::exception& e) {
44027       {
44028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44029       };
44030     } catch (...) {
44031       {
44032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44033       };
44034     }
44035   }
44036 }
44037
44038
44039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44040   int jresult ;
44041   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44042   Dali::Camera::ProjectionMode result;
44043
44044   arg1 = (Dali::CameraActor *)jarg1;
44045   {
44046     try {
44047       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44048     } catch (std::out_of_range& e) {
44049       {
44050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44051       };
44052     } catch (std::exception& e) {
44053       {
44054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44055       };
44056     } catch (...) {
44057       {
44058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44059       };
44060     }
44061   }
44062   jresult = (int)result;
44063   return jresult;
44064 }
44065
44066
44067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44068   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44069   float arg2 ;
44070
44071   arg1 = (Dali::CameraActor *)jarg1;
44072   arg2 = (float)jarg2;
44073   {
44074     try {
44075       (arg1)->SetFieldOfView(arg2);
44076     } catch (std::out_of_range& e) {
44077       {
44078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44079       };
44080     } catch (std::exception& e) {
44081       {
44082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44083       };
44084     } catch (...) {
44085       {
44086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44087       };
44088     }
44089   }
44090 }
44091
44092
44093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44094   float jresult ;
44095   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44096   float result;
44097
44098   arg1 = (Dali::CameraActor *)jarg1;
44099   {
44100     try {
44101       result = (float)(arg1)->GetFieldOfView();
44102     } catch (std::out_of_range& e) {
44103       {
44104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44105       };
44106     } catch (std::exception& e) {
44107       {
44108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44109       };
44110     } catch (...) {
44111       {
44112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44113       };
44114     }
44115   }
44116   jresult = result;
44117   return jresult;
44118 }
44119
44120
44121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44122   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44123   float arg2 ;
44124
44125   arg1 = (Dali::CameraActor *)jarg1;
44126   arg2 = (float)jarg2;
44127   {
44128     try {
44129       (arg1)->SetAspectRatio(arg2);
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (...) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44141       };
44142     }
44143   }
44144 }
44145
44146
44147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44148   float jresult ;
44149   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44150   float result;
44151
44152   arg1 = (Dali::CameraActor *)jarg1;
44153   {
44154     try {
44155       result = (float)(arg1)->GetAspectRatio();
44156     } catch (std::out_of_range& e) {
44157       {
44158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44159       };
44160     } catch (std::exception& e) {
44161       {
44162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44163       };
44164     } catch (...) {
44165       {
44166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44167       };
44168     }
44169   }
44170   jresult = result;
44171   return jresult;
44172 }
44173
44174
44175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44176   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44177   float arg2 ;
44178
44179   arg1 = (Dali::CameraActor *)jarg1;
44180   arg2 = (float)jarg2;
44181   {
44182     try {
44183       (arg1)->SetNearClippingPlane(arg2);
44184     } catch (std::out_of_range& e) {
44185       {
44186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44187       };
44188     } catch (std::exception& e) {
44189       {
44190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44191       };
44192     } catch (...) {
44193       {
44194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44195       };
44196     }
44197   }
44198 }
44199
44200
44201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44202   float jresult ;
44203   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44204   float result;
44205
44206   arg1 = (Dali::CameraActor *)jarg1;
44207   {
44208     try {
44209       result = (float)(arg1)->GetNearClippingPlane();
44210     } catch (std::out_of_range& e) {
44211       {
44212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44213       };
44214     } catch (std::exception& e) {
44215       {
44216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44217       };
44218     } catch (...) {
44219       {
44220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44221       };
44222     }
44223   }
44224   jresult = result;
44225   return jresult;
44226 }
44227
44228
44229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44230   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44231   float arg2 ;
44232
44233   arg1 = (Dali::CameraActor *)jarg1;
44234   arg2 = (float)jarg2;
44235   {
44236     try {
44237       (arg1)->SetFarClippingPlane(arg2);
44238     } catch (std::out_of_range& e) {
44239       {
44240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44241       };
44242     } catch (std::exception& e) {
44243       {
44244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44245       };
44246     } catch (...) {
44247       {
44248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44249       };
44250     }
44251   }
44252 }
44253
44254
44255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44256   float jresult ;
44257   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44258   float result;
44259
44260   arg1 = (Dali::CameraActor *)jarg1;
44261   {
44262     try {
44263       result = (float)(arg1)->GetFarClippingPlane();
44264     } catch (std::out_of_range& e) {
44265       {
44266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44267       };
44268     } catch (std::exception& e) {
44269       {
44270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44271       };
44272     } catch (...) {
44273       {
44274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44275       };
44276     }
44277   }
44278   jresult = result;
44279   return jresult;
44280 }
44281
44282
44283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44284   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44285   Dali::Vector3 *arg2 = 0 ;
44286
44287   arg1 = (Dali::CameraActor *)jarg1;
44288   arg2 = (Dali::Vector3 *)jarg2;
44289   if (!arg2) {
44290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44291     return ;
44292   }
44293   {
44294     try {
44295       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44296     } catch (std::out_of_range& e) {
44297       {
44298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44299       };
44300     } catch (std::exception& e) {
44301       {
44302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44303       };
44304     } catch (...) {
44305       {
44306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44307       };
44308     }
44309   }
44310 }
44311
44312
44313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44314   void * jresult ;
44315   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44316   Dali::Vector3 result;
44317
44318   arg1 = (Dali::CameraActor *)jarg1;
44319   {
44320     try {
44321       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44322     } catch (std::out_of_range& e) {
44323       {
44324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44325       };
44326     } catch (std::exception& e) {
44327       {
44328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (...) {
44331       {
44332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44333       };
44334     }
44335   }
44336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44337   return jresult;
44338 }
44339
44340
44341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44342   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44343   bool arg2 ;
44344
44345   arg1 = (Dali::CameraActor *)jarg1;
44346   arg2 = jarg2 ? true : false;
44347   {
44348     try {
44349       (arg1)->SetInvertYAxis(arg2);
44350     } catch (std::out_of_range& e) {
44351       {
44352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44353       };
44354     } catch (std::exception& e) {
44355       {
44356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44357       };
44358     } catch (...) {
44359       {
44360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44361       };
44362     }
44363   }
44364 }
44365
44366
44367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44368   unsigned int jresult ;
44369   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44370   bool result;
44371
44372   arg1 = (Dali::CameraActor *)jarg1;
44373   {
44374     try {
44375       result = (bool)(arg1)->GetInvertYAxis();
44376     } catch (std::out_of_range& e) {
44377       {
44378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44379       };
44380     } catch (std::exception& e) {
44381       {
44382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44383       };
44384     } catch (...) {
44385       {
44386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44387       };
44388     }
44389   }
44390   jresult = result;
44391   return jresult;
44392 }
44393
44394
44395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44396   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44397   Dali::Size *arg2 = 0 ;
44398
44399   arg1 = (Dali::CameraActor *)jarg1;
44400   arg2 = (Dali::Size *)jarg2;
44401   if (!arg2) {
44402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44403     return ;
44404   }
44405   {
44406     try {
44407       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44408     } catch (std::out_of_range& e) {
44409       {
44410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44411       };
44412     } catch (std::exception& e) {
44413       {
44414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44415       };
44416     } catch (...) {
44417       {
44418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44419       };
44420     }
44421   }
44422 }
44423
44424
44425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44426   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44427   Dali::Size *arg2 = 0 ;
44428
44429   arg1 = (Dali::CameraActor *)jarg1;
44430   arg2 = (Dali::Size *)jarg2;
44431   if (!arg2) {
44432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44433     return ;
44434   }
44435   {
44436     try {
44437       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44438     } catch (std::out_of_range& e) {
44439       {
44440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44441       };
44442     } catch (std::exception& e) {
44443       {
44444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44445       };
44446     } catch (...) {
44447       {
44448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44449       };
44450     }
44451   }
44452 }
44453
44454
44455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44456   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44457   float arg2 ;
44458   float arg3 ;
44459   float arg4 ;
44460   float arg5 ;
44461   float arg6 ;
44462   float arg7 ;
44463
44464   arg1 = (Dali::CameraActor *)jarg1;
44465   arg2 = (float)jarg2;
44466   arg3 = (float)jarg3;
44467   arg4 = (float)jarg4;
44468   arg5 = (float)jarg5;
44469   arg6 = (float)jarg6;
44470   arg7 = (float)jarg7;
44471   {
44472     try {
44473       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44474     } catch (std::out_of_range& e) {
44475       {
44476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (std::exception& e) {
44479       {
44480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (...) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44485       };
44486     }
44487   }
44488 }
44489
44490
44491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44492   void * jresult ;
44493   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44494
44495   {
44496     try {
44497       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44498     } catch (std::out_of_range& e) {
44499       {
44500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44501       };
44502     } catch (std::exception& e) {
44503       {
44504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44505       };
44506     } catch (...) {
44507       {
44508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44509       };
44510     }
44511   }
44512   jresult = (void *)result;
44513   return jresult;
44514 }
44515
44516
44517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44518   void * jresult ;
44519   std::string arg1 ;
44520   Dali::Property::Value arg2 ;
44521   Dali::Property::Value *argp2 ;
44522   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44523
44524   if (!jarg1) {
44525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44526     return 0;
44527   }
44528   (&arg1)->assign(jarg1);
44529   argp2 = (Dali::Property::Value *)jarg2;
44530   if (!argp2) {
44531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44532     return 0;
44533   }
44534   arg2 = *argp2;
44535   {
44536     try {
44537       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44538     } catch (std::out_of_range& e) {
44539       {
44540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44541       };
44542     } catch (std::exception& e) {
44543       {
44544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44545       };
44546     } catch (...) {
44547       {
44548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44549       };
44550     }
44551   }
44552   jresult = (void *)result;
44553   return jresult;
44554 }
44555
44556
44557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44558   void * jresult ;
44559   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44560   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44561
44562   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44563   if (!arg1) {
44564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44565     return 0;
44566   }
44567   {
44568     try {
44569       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);
44570     } catch (std::out_of_range& e) {
44571       {
44572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44573       };
44574     } catch (std::exception& e) {
44575       {
44576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44577       };
44578     } catch (...) {
44579       {
44580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44581       };
44582     }
44583   }
44584   jresult = (void *)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44590   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44591   std::string *arg2 = 0 ;
44592
44593   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44594   if (!jarg2) {
44595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44596     return ;
44597   }
44598   std::string arg2_str(jarg2);
44599   arg2 = &arg2_str;
44600   if (arg1) (arg1)->first = *arg2;
44601
44602   //argout typemap for const std::string&
44603
44604 }
44605
44606
44607 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44608   char * jresult ;
44609   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44610   std::string *result = 0 ;
44611
44612   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44613   result = (std::string *) & ((arg1)->first);
44614   jresult = SWIG_csharp_string_callback(result->c_str());
44615   return jresult;
44616 }
44617
44618
44619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44620   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44621   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44622
44623   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44624   arg2 = (Dali::Property::Value *)jarg2;
44625   if (arg1) (arg1)->second = *arg2;
44626 }
44627
44628
44629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44630   void * jresult ;
44631   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44632   Dali::Property::Value *result = 0 ;
44633
44634   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44635   result = (Dali::Property::Value *)& ((arg1)->second);
44636   jresult = (void *)result;
44637   return jresult;
44638 }
44639
44640
44641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44642   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44643
44644   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44645   {
44646     try {
44647       delete arg1;
44648     } catch (std::out_of_range& e) {
44649       {
44650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44651       };
44652     } catch (std::exception& e) {
44653       {
44654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44655       };
44656     } catch (...) {
44657       {
44658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44659       };
44660     }
44661   }
44662 }
44663
44664
44665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44666   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44667
44668   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44669   {
44670     try {
44671       (arg1)->clear();
44672     } catch (std::out_of_range& e) {
44673       {
44674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44675       };
44676     } catch (std::exception& e) {
44677       {
44678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44679       };
44680     } catch (...) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44683       };
44684     }
44685   }
44686 }
44687
44688
44689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44690   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44691   Dali::TouchPoint *arg2 = 0 ;
44692
44693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44694   arg2 = (Dali::TouchPoint *)jarg2;
44695   if (!arg2) {
44696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44697     return ;
44698   }
44699   {
44700     try {
44701       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44702     } catch (std::out_of_range& e) {
44703       {
44704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44705       };
44706     } catch (std::exception& e) {
44707       {
44708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44709       };
44710     } catch (...) {
44711       {
44712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44713       };
44714     }
44715   }
44716 }
44717
44718
44719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44720   unsigned long jresult ;
44721   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44722   std::vector< Dali::TouchPoint >::size_type result;
44723
44724   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44725   {
44726     try {
44727       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44728     } catch (std::out_of_range& e) {
44729       {
44730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44731       };
44732     } catch (std::exception& e) {
44733       {
44734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44735       };
44736     } catch (...) {
44737       {
44738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44739       };
44740     }
44741   }
44742   jresult = (unsigned long)result;
44743   return jresult;
44744 }
44745
44746
44747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44748   unsigned long jresult ;
44749   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44750   std::vector< Dali::TouchPoint >::size_type result;
44751
44752   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44753   {
44754     try {
44755       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44756     } catch (std::out_of_range& e) {
44757       {
44758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44759       };
44760     } catch (std::exception& e) {
44761       {
44762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (...) {
44765       {
44766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44767       };
44768     }
44769   }
44770   jresult = (unsigned long)result;
44771   return jresult;
44772 }
44773
44774
44775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44776   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44777   std::vector< Dali::TouchPoint >::size_type arg2 ;
44778
44779   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44780   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44781   {
44782     try {
44783       (arg1)->reserve(arg2);
44784     } catch (std::out_of_range& e) {
44785       {
44786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44787       };
44788     } catch (std::exception& e) {
44789       {
44790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44791       };
44792     } catch (...) {
44793       {
44794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44795       };
44796     }
44797   }
44798 }
44799
44800
44801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44802   void * jresult ;
44803   std::vector< Dali::TouchPoint > *result = 0 ;
44804
44805   {
44806     try {
44807       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44808     } catch (std::out_of_range& e) {
44809       {
44810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44811       };
44812     } catch (std::exception& e) {
44813       {
44814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44815       };
44816     } catch (...) {
44817       {
44818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44819       };
44820     }
44821   }
44822   jresult = (void *)result;
44823   return jresult;
44824 }
44825
44826
44827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44828   void * jresult ;
44829   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44830   std::vector< Dali::TouchPoint > *result = 0 ;
44831
44832   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44833   if (!arg1) {
44834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44835     return 0;
44836   }
44837   {
44838     try {
44839       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44840     } catch (std::out_of_range& e) {
44841       {
44842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44843       };
44844     } catch (std::exception& e) {
44845       {
44846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44847       };
44848     } catch (...) {
44849       {
44850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44851       };
44852     }
44853   }
44854   jresult = (void *)result;
44855   return jresult;
44856 }
44857
44858
44859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44860   void * jresult ;
44861   int arg1 ;
44862   std::vector< Dali::TouchPoint > *result = 0 ;
44863
44864   arg1 = (int)jarg1;
44865   {
44866     try {
44867       try {
44868         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44869       }
44870       catch(std::out_of_range &_e) {
44871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44872         return 0;
44873       }
44874
44875     } catch (std::out_of_range& e) {
44876       {
44877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44878       };
44879     } catch (std::exception& e) {
44880       {
44881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44882       };
44883     } catch (...) {
44884       {
44885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44886       };
44887     }
44888   }
44889   jresult = (void *)result;
44890   return jresult;
44891 }
44892
44893
44894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44895   void * jresult ;
44896   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44897   int arg2 ;
44898   SwigValueWrapper< Dali::TouchPoint > result;
44899
44900   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44901   arg2 = (int)jarg2;
44902   {
44903     try {
44904       try {
44905         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44906       }
44907       catch(std::out_of_range &_e) {
44908         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44909         return 0;
44910       }
44911
44912     } catch (std::out_of_range& e) {
44913       {
44914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44915       };
44916     } catch (std::exception& e) {
44917       {
44918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44919       };
44920     } catch (...) {
44921       {
44922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44923       };
44924     }
44925   }
44926   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44927   return jresult;
44928 }
44929
44930
44931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44932   void * jresult ;
44933   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44934   int arg2 ;
44935   Dali::TouchPoint *result = 0 ;
44936
44937   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44938   arg2 = (int)jarg2;
44939   {
44940     try {
44941       try {
44942         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44943       }
44944       catch(std::out_of_range &_e) {
44945         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44946         return 0;
44947       }
44948
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44956       };
44957     } catch (...) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44960       };
44961     }
44962   }
44963   jresult = (void *)result;
44964   return jresult;
44965 }
44966
44967
44968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44969   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44970   int arg2 ;
44971   Dali::TouchPoint *arg3 = 0 ;
44972
44973   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44974   arg2 = (int)jarg2;
44975   arg3 = (Dali::TouchPoint *)jarg3;
44976   if (!arg3) {
44977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44978     return ;
44979   }
44980   {
44981     try {
44982       try {
44983         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44984       }
44985       catch(std::out_of_range &_e) {
44986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44987         return ;
44988       }
44989
44990     } catch (std::out_of_range& e) {
44991       {
44992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44993       };
44994     } catch (std::exception& e) {
44995       {
44996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44997       };
44998     } catch (...) {
44999       {
45000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45001       };
45002     }
45003   }
45004 }
45005
45006
45007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45008   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45009   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45010
45011   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45012   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45013   if (!arg2) {
45014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45015     return ;
45016   }
45017   {
45018     try {
45019       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45020     } catch (std::out_of_range& e) {
45021       {
45022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45023       };
45024     } catch (std::exception& e) {
45025       {
45026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45027       };
45028     } catch (...) {
45029       {
45030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45031       };
45032     }
45033   }
45034 }
45035
45036
45037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45038   void * jresult ;
45039   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45040   int arg2 ;
45041   int arg3 ;
45042   std::vector< Dali::TouchPoint > *result = 0 ;
45043
45044   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45045   arg2 = (int)jarg2;
45046   arg3 = (int)jarg3;
45047   {
45048     try {
45049       try {
45050         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45051       }
45052       catch(std::out_of_range &_e) {
45053         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45054         return 0;
45055       }
45056       catch(std::invalid_argument &_e) {
45057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45058         return 0;
45059       }
45060
45061     } catch (std::out_of_range& e) {
45062       {
45063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45064       };
45065     } catch (std::exception& e) {
45066       {
45067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45068       };
45069     } catch (...) {
45070       {
45071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45072       };
45073     }
45074   }
45075   jresult = (void *)result;
45076   return jresult;
45077 }
45078
45079
45080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45081   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45082   int arg2 ;
45083   Dali::TouchPoint *arg3 = 0 ;
45084
45085   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45086   arg2 = (int)jarg2;
45087   arg3 = (Dali::TouchPoint *)jarg3;
45088   if (!arg3) {
45089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45090     return ;
45091   }
45092   {
45093     try {
45094       try {
45095         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45096       }
45097       catch(std::out_of_range &_e) {
45098         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45099         return ;
45100       }
45101
45102     } catch (std::out_of_range& e) {
45103       {
45104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45105       };
45106     } catch (std::exception& e) {
45107       {
45108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45109       };
45110     } catch (...) {
45111       {
45112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45113       };
45114     }
45115   }
45116 }
45117
45118
45119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45120   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45121   int arg2 ;
45122   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45123
45124   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45125   arg2 = (int)jarg2;
45126   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45127   if (!arg3) {
45128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45129     return ;
45130   }
45131   {
45132     try {
45133       try {
45134         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45135       }
45136       catch(std::out_of_range &_e) {
45137         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45138         return ;
45139       }
45140
45141     } catch (std::out_of_range& e) {
45142       {
45143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45144       };
45145     } catch (std::exception& e) {
45146       {
45147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45148       };
45149     } catch (...) {
45150       {
45151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45152       };
45153     }
45154   }
45155 }
45156
45157
45158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45159   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45160   int arg2 ;
45161
45162   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45163   arg2 = (int)jarg2;
45164   {
45165     try {
45166       try {
45167         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45168       }
45169       catch(std::out_of_range &_e) {
45170         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45171         return ;
45172       }
45173
45174     } catch (std::out_of_range& e) {
45175       {
45176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45177       };
45178     } catch (std::exception& e) {
45179       {
45180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45181       };
45182     } catch (...) {
45183       {
45184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45185       };
45186     }
45187   }
45188 }
45189
45190
45191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45192   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45193   int arg2 ;
45194   int arg3 ;
45195
45196   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45197   arg2 = (int)jarg2;
45198   arg3 = (int)jarg3;
45199   {
45200     try {
45201       try {
45202         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45203       }
45204       catch(std::out_of_range &_e) {
45205         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45206         return ;
45207       }
45208       catch(std::invalid_argument &_e) {
45209         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45210         return ;
45211       }
45212
45213     } catch (std::out_of_range& e) {
45214       {
45215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45216       };
45217     } catch (std::exception& e) {
45218       {
45219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45220       };
45221     } catch (...) {
45222       {
45223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45224       };
45225     }
45226   }
45227 }
45228
45229
45230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45231   void * jresult ;
45232   Dali::TouchPoint *arg1 = 0 ;
45233   int arg2 ;
45234   std::vector< Dali::TouchPoint > *result = 0 ;
45235
45236   arg1 = (Dali::TouchPoint *)jarg1;
45237   if (!arg1) {
45238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45239     return 0;
45240   }
45241   arg2 = (int)jarg2;
45242   {
45243     try {
45244       try {
45245         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45246       }
45247       catch(std::out_of_range &_e) {
45248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45249         return 0;
45250       }
45251
45252     } catch (std::out_of_range& e) {
45253       {
45254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45255       };
45256     } catch (std::exception& e) {
45257       {
45258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45259       };
45260     } catch (...) {
45261       {
45262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45263       };
45264     }
45265   }
45266   jresult = (void *)result;
45267   return jresult;
45268 }
45269
45270
45271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45272   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45273
45274   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45275   {
45276     try {
45277       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45278     } catch (std::out_of_range& e) {
45279       {
45280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45281       };
45282     } catch (std::exception& e) {
45283       {
45284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45285       };
45286     } catch (...) {
45287       {
45288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45289       };
45290     }
45291   }
45292 }
45293
45294
45295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45296   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45297   int arg2 ;
45298   int arg3 ;
45299
45300   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45301   arg2 = (int)jarg2;
45302   arg3 = (int)jarg3;
45303   {
45304     try {
45305       try {
45306         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45307       }
45308       catch(std::out_of_range &_e) {
45309         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45310         return ;
45311       }
45312       catch(std::invalid_argument &_e) {
45313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45314         return ;
45315       }
45316
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45324       };
45325     } catch (...) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45328       };
45329     }
45330   }
45331 }
45332
45333
45334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45335   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45336   int arg2 ;
45337   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45338
45339   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45340   arg2 = (int)jarg2;
45341   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45342   if (!arg3) {
45343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45344     return ;
45345   }
45346   {
45347     try {
45348       try {
45349         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45350       }
45351       catch(std::out_of_range &_e) {
45352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45353         return ;
45354       }
45355
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45363       };
45364     } catch (...) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45367       };
45368     }
45369   }
45370 }
45371
45372
45373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45374   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45375
45376   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45377   {
45378     try {
45379       delete arg1;
45380     } catch (std::out_of_range& e) {
45381       {
45382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45383       };
45384     } catch (std::exception& e) {
45385       {
45386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45387       };
45388     } catch (...) {
45389       {
45390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45391       };
45392     }
45393   }
45394 }
45395
45396
45397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45398   void * jresult ;
45399   Dali::Rect< int > *result = 0 ;
45400
45401   {
45402     try {
45403       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45404     } catch (std::out_of_range& e) {
45405       {
45406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (std::exception& e) {
45409       {
45410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45411       };
45412     } catch (...) {
45413       {
45414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45415       };
45416     }
45417   }
45418   jresult = (void *)result;
45419   return jresult;
45420 }
45421
45422
45423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45424   void * jresult ;
45425   int arg1 ;
45426   int arg2 ;
45427   int arg3 ;
45428   int arg4 ;
45429   Dali::Rect< int > *result = 0 ;
45430
45431   arg1 = (int)jarg1;
45432   arg2 = (int)jarg2;
45433   arg3 = (int)jarg3;
45434   arg4 = (int)jarg4;
45435   {
45436     try {
45437       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45438     } catch (std::out_of_range& e) {
45439       {
45440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (std::exception& e) {
45443       {
45444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45445       };
45446     } catch (...) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45449       };
45450     }
45451   }
45452   jresult = (void *)result;
45453   return jresult;
45454 }
45455
45456
45457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45458   void * jresult ;
45459   Dali::Rect< int > *arg1 = 0 ;
45460   Dali::Rect< int > *result = 0 ;
45461
45462   arg1 = (Dali::Rect< int > *)jarg1;
45463   if (!arg1) {
45464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45465     return 0;
45466   }
45467   {
45468     try {
45469       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45470     } catch (std::out_of_range& e) {
45471       {
45472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45473       };
45474     } catch (std::exception& e) {
45475       {
45476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45477       };
45478     } catch (...) {
45479       {
45480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45481       };
45482     }
45483   }
45484   jresult = (void *)result;
45485   return jresult;
45486 }
45487
45488
45489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45490   void * jresult ;
45491   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45492   Dali::Rect< int > *arg2 = 0 ;
45493   Dali::Rect< int > *result = 0 ;
45494
45495   arg1 = (Dali::Rect< int > *)jarg1;
45496   arg2 = (Dali::Rect< int > *)jarg2;
45497   if (!arg2) {
45498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45499     return 0;
45500   }
45501   {
45502     try {
45503       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45504     } catch (std::out_of_range& e) {
45505       {
45506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (std::exception& e) {
45509       {
45510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45511       };
45512     } catch (...) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45515       };
45516     }
45517   }
45518   jresult = (void *)result;
45519   return jresult;
45520 }
45521
45522
45523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45525   int arg2 ;
45526   int arg3 ;
45527   int arg4 ;
45528   int arg5 ;
45529
45530   arg1 = (Dali::Rect< int > *)jarg1;
45531   arg2 = (int)jarg2;
45532   arg3 = (int)jarg3;
45533   arg4 = (int)jarg4;
45534   arg5 = (int)jarg5;
45535   {
45536     try {
45537       (arg1)->Set(arg2,arg3,arg4,arg5);
45538     } catch (std::out_of_range& e) {
45539       {
45540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (std::exception& e) {
45543       {
45544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45545       };
45546     } catch (...) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45549       };
45550     }
45551   }
45552 }
45553
45554
45555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45556   unsigned int jresult ;
45557   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45558   bool result;
45559
45560   arg1 = (Dali::Rect< int > *)jarg1;
45561   {
45562     try {
45563       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45564     } catch (std::out_of_range& e) {
45565       {
45566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45567       };
45568     } catch (std::exception& e) {
45569       {
45570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45571       };
45572     } catch (...) {
45573       {
45574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45575       };
45576     }
45577   }
45578   jresult = result;
45579   return jresult;
45580 }
45581
45582
45583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45584   int jresult ;
45585   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45586   int result;
45587
45588   arg1 = (Dali::Rect< int > *)jarg1;
45589   {
45590     try {
45591       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45592     } catch (std::out_of_range& e) {
45593       {
45594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45595       };
45596     } catch (std::exception& e) {
45597       {
45598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (...) {
45601       {
45602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45603       };
45604     }
45605   }
45606   jresult = result;
45607   return jresult;
45608 }
45609
45610
45611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45612   int jresult ;
45613   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45614   int result;
45615
45616   arg1 = (Dali::Rect< int > *)jarg1;
45617   {
45618     try {
45619       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45620     } catch (std::out_of_range& e) {
45621       {
45622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45623       };
45624     } catch (std::exception& e) {
45625       {
45626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45627       };
45628     } catch (...) {
45629       {
45630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45631       };
45632     }
45633   }
45634   jresult = result;
45635   return jresult;
45636 }
45637
45638
45639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45640   int jresult ;
45641   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45642   int result;
45643
45644   arg1 = (Dali::Rect< int > *)jarg1;
45645   {
45646     try {
45647       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45648     } catch (std::out_of_range& e) {
45649       {
45650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45651       };
45652     } catch (std::exception& e) {
45653       {
45654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45655       };
45656     } catch (...) {
45657       {
45658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45659       };
45660     }
45661   }
45662   jresult = result;
45663   return jresult;
45664 }
45665
45666
45667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45668   int jresult ;
45669   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45670   int result;
45671
45672   arg1 = (Dali::Rect< int > *)jarg1;
45673   {
45674     try {
45675       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45676     } catch (std::out_of_range& e) {
45677       {
45678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45679       };
45680     } catch (std::exception& e) {
45681       {
45682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45683       };
45684     } catch (...) {
45685       {
45686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45687       };
45688     }
45689   }
45690   jresult = result;
45691   return jresult;
45692 }
45693
45694
45695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45696   int jresult ;
45697   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45698   int result;
45699
45700   arg1 = (Dali::Rect< int > *)jarg1;
45701   {
45702     try {
45703       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45704     } catch (std::out_of_range& e) {
45705       {
45706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45707       };
45708     } catch (std::exception& e) {
45709       {
45710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45711       };
45712     } catch (...) {
45713       {
45714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45715       };
45716     }
45717   }
45718   jresult = result;
45719   return jresult;
45720 }
45721
45722
45723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45724   unsigned int jresult ;
45725   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45726   Dali::Rect< int > *arg2 = 0 ;
45727   bool result;
45728
45729   arg1 = (Dali::Rect< int > *)jarg1;
45730   arg2 = (Dali::Rect< int > *)jarg2;
45731   if (!arg2) {
45732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45733     return 0;
45734   }
45735   {
45736     try {
45737       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45738     } catch (std::out_of_range& e) {
45739       {
45740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45741       };
45742     } catch (std::exception& e) {
45743       {
45744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45745       };
45746     } catch (...) {
45747       {
45748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45749       };
45750     }
45751   }
45752   jresult = result;
45753   return jresult;
45754 }
45755
45756
45757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45758   unsigned int jresult ;
45759   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45760   Dali::Rect< int > *arg2 = 0 ;
45761   bool result;
45762
45763   arg1 = (Dali::Rect< int > *)jarg1;
45764   arg2 = (Dali::Rect< int > *)jarg2;
45765   if (!arg2) {
45766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45767     return 0;
45768   }
45769   {
45770     try {
45771       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45772     } catch (std::out_of_range& e) {
45773       {
45774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45775       };
45776     } catch (std::exception& e) {
45777       {
45778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45779       };
45780     } catch (...) {
45781       {
45782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45783       };
45784     }
45785   }
45786   jresult = result;
45787   return jresult;
45788 }
45789
45790
45791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45792   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45793   int arg2 ;
45794
45795   arg1 = (Dali::Rect< int > *)jarg1;
45796   arg2 = (int)jarg2;
45797   if (arg1) (arg1)->x = arg2;
45798 }
45799
45800
45801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45802   int jresult ;
45803   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45804   int result;
45805
45806   arg1 = (Dali::Rect< int > *)jarg1;
45807   result = (int) ((arg1)->x);
45808   jresult = result;
45809   return jresult;
45810 }
45811
45812
45813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45814   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45815   int arg2 ;
45816
45817   arg1 = (Dali::Rect< int > *)jarg1;
45818   arg2 = (int)jarg2;
45819   if (arg1) (arg1)->left = arg2;
45820 }
45821
45822
45823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45824   int jresult ;
45825   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45826   int result;
45827
45828   arg1 = (Dali::Rect< int > *)jarg1;
45829   result = (int) ((arg1)->left);
45830   jresult = result;
45831   return jresult;
45832 }
45833
45834
45835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45836   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45837   int arg2 ;
45838
45839   arg1 = (Dali::Rect< int > *)jarg1;
45840   arg2 = (int)jarg2;
45841   if (arg1) (arg1)->y = arg2;
45842 }
45843
45844
45845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45846   int jresult ;
45847   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45848   int result;
45849
45850   arg1 = (Dali::Rect< int > *)jarg1;
45851   result = (int) ((arg1)->y);
45852   jresult = result;
45853   return jresult;
45854 }
45855
45856
45857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45858   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45859   int arg2 ;
45860
45861   arg1 = (Dali::Rect< int > *)jarg1;
45862   arg2 = (int)jarg2;
45863   if (arg1) (arg1)->right = arg2;
45864 }
45865
45866
45867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45868   int jresult ;
45869   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45870   int result;
45871
45872   arg1 = (Dali::Rect< int > *)jarg1;
45873   result = (int) ((arg1)->right);
45874   jresult = result;
45875   return jresult;
45876 }
45877
45878
45879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45880   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45881   int arg2 ;
45882
45883   arg1 = (Dali::Rect< int > *)jarg1;
45884   arg2 = (int)jarg2;
45885   if (arg1) (arg1)->width = arg2;
45886 }
45887
45888
45889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45890   int jresult ;
45891   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45892   int result;
45893
45894   arg1 = (Dali::Rect< int > *)jarg1;
45895   result = (int) ((arg1)->width);
45896   jresult = result;
45897   return jresult;
45898 }
45899
45900
45901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45902   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45903   int arg2 ;
45904
45905   arg1 = (Dali::Rect< int > *)jarg1;
45906   arg2 = (int)jarg2;
45907   if (arg1) (arg1)->bottom = arg2;
45908 }
45909
45910
45911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45912   int jresult ;
45913   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45914   int result;
45915
45916   arg1 = (Dali::Rect< int > *)jarg1;
45917   result = (int) ((arg1)->bottom);
45918   jresult = result;
45919   return jresult;
45920 }
45921
45922
45923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45924   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45925   int arg2 ;
45926
45927   arg1 = (Dali::Rect< int > *)jarg1;
45928   arg2 = (int)jarg2;
45929   if (arg1) (arg1)->height = arg2;
45930 }
45931
45932
45933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45934   int jresult ;
45935   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45936   int result;
45937
45938   arg1 = (Dali::Rect< int > *)jarg1;
45939   result = (int) ((arg1)->height);
45940   jresult = result;
45941   return jresult;
45942 }
45943
45944
45945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45946   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45947   int arg2 ;
45948
45949   arg1 = (Dali::Rect< int > *)jarg1;
45950   arg2 = (int)jarg2;
45951   if (arg1) (arg1)->top = arg2;
45952 }
45953
45954
45955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45956   int jresult ;
45957   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45958   int result;
45959
45960   arg1 = (Dali::Rect< int > *)jarg1;
45961   result = (int) ((arg1)->top);
45962   jresult = result;
45963   return jresult;
45964 }
45965
45966
45967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45968   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45969
45970   arg1 = (Dali::Rect< int > *)jarg1;
45971   {
45972     try {
45973       delete arg1;
45974     } catch (std::out_of_range& e) {
45975       {
45976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45977       };
45978     } catch (std::exception& e) {
45979       {
45980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45981       };
45982     } catch (...) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45985       };
45986     }
45987   }
45988 }
45989
45990
45991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45992   void * jresult ;
45993   Dali::Rect< float > *result = 0 ;
45994
45995   {
45996     try {
45997       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45998     } catch (std::out_of_range& e) {
45999       {
46000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46001       };
46002     } catch (std::exception& e) {
46003       {
46004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (...) {
46007       {
46008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46009       };
46010     }
46011   }
46012   jresult = (void *)result;
46013   return jresult;
46014 }
46015
46016
46017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46018   void * jresult ;
46019   float arg1 ;
46020   float arg2 ;
46021   float arg3 ;
46022   float arg4 ;
46023   Dali::Rect< float > *result = 0 ;
46024
46025   arg1 = (float)jarg1;
46026   arg2 = (float)jarg2;
46027   arg3 = (float)jarg3;
46028   arg4 = (float)jarg4;
46029   {
46030     try {
46031       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46032     } catch (std::out_of_range& e) {
46033       {
46034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46035       };
46036     } catch (std::exception& e) {
46037       {
46038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46039       };
46040     } catch (...) {
46041       {
46042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46043       };
46044     }
46045   }
46046   jresult = (void *)result;
46047   return jresult;
46048 }
46049
46050
46051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46052   void * jresult ;
46053   Dali::Rect< float > *arg1 = 0 ;
46054   Dali::Rect< float > *result = 0 ;
46055
46056   arg1 = (Dali::Rect< float > *)jarg1;
46057   if (!arg1) {
46058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46059     return 0;
46060   }
46061   {
46062     try {
46063       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46064     } catch (std::out_of_range& e) {
46065       {
46066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46067       };
46068     } catch (std::exception& e) {
46069       {
46070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46071       };
46072     } catch (...) {
46073       {
46074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46075       };
46076     }
46077   }
46078   jresult = (void *)result;
46079   return jresult;
46080 }
46081
46082
46083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46084   void * jresult ;
46085   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46086   Dali::Rect< float > *arg2 = 0 ;
46087   Dali::Rect< float > *result = 0 ;
46088
46089   arg1 = (Dali::Rect< float > *)jarg1;
46090   arg2 = (Dali::Rect< float > *)jarg2;
46091   if (!arg2) {
46092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46093     return 0;
46094   }
46095   {
46096     try {
46097       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46098     } catch (std::out_of_range& e) {
46099       {
46100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (std::exception& e) {
46103       {
46104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46109       };
46110     }
46111   }
46112   jresult = (void *)result;
46113   return jresult;
46114 }
46115
46116
46117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46118   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46119   float arg2 ;
46120   float arg3 ;
46121   float arg4 ;
46122   float arg5 ;
46123
46124   arg1 = (Dali::Rect< float > *)jarg1;
46125   arg2 = (float)jarg2;
46126   arg3 = (float)jarg3;
46127   arg4 = (float)jarg4;
46128   arg5 = (float)jarg5;
46129   {
46130     try {
46131       (arg1)->Set(arg2,arg3,arg4,arg5);
46132     } catch (std::out_of_range& e) {
46133       {
46134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46135       };
46136     } catch (std::exception& e) {
46137       {
46138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46139       };
46140     } catch (...) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46143       };
46144     }
46145   }
46146 }
46147
46148
46149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46150   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46151   float arg2 ;
46152
46153   arg1 = (Dali::Rect< float > *)jarg1;
46154   arg2 = (float)jarg2;
46155   if (arg1) (arg1)->x = arg2;
46156 }
46157
46158
46159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46160   float jresult ;
46161   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46162   float result;
46163
46164   arg1 = (Dali::Rect< float > *)jarg1;
46165   result = (float) ((arg1)->x);
46166   jresult = result;
46167   return jresult;
46168 }
46169
46170
46171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46172   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46173   float arg2 ;
46174
46175   arg1 = (Dali::Rect< float > *)jarg1;
46176   arg2 = (float)jarg2;
46177   if (arg1) (arg1)->left = arg2;
46178 }
46179
46180
46181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46182   float jresult ;
46183   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46184   float result;
46185
46186   arg1 = (Dali::Rect< float > *)jarg1;
46187   result = (float) ((arg1)->left);
46188   jresult = result;
46189   return jresult;
46190 }
46191
46192
46193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46194   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46195   float arg2 ;
46196
46197   arg1 = (Dali::Rect< float > *)jarg1;
46198   arg2 = (float)jarg2;
46199   if (arg1) (arg1)->y = arg2;
46200 }
46201
46202
46203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46204   float jresult ;
46205   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46206   float result;
46207
46208   arg1 = (Dali::Rect< float > *)jarg1;
46209   result = (float) ((arg1)->y);
46210   jresult = result;
46211   return jresult;
46212 }
46213
46214
46215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46216   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46217   float arg2 ;
46218
46219   arg1 = (Dali::Rect< float > *)jarg1;
46220   arg2 = (float)jarg2;
46221   if (arg1) (arg1)->right = arg2;
46222 }
46223
46224
46225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46226   float jresult ;
46227   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46228   float result;
46229
46230   arg1 = (Dali::Rect< float > *)jarg1;
46231   result = (float) ((arg1)->right);
46232   jresult = result;
46233   return jresult;
46234 }
46235
46236
46237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46238   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46239   float arg2 ;
46240
46241   arg1 = (Dali::Rect< float > *)jarg1;
46242   arg2 = (float)jarg2;
46243   if (arg1) (arg1)->width = arg2;
46244 }
46245
46246
46247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46248   float jresult ;
46249   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46250   float result;
46251
46252   arg1 = (Dali::Rect< float > *)jarg1;
46253   result = (float) ((arg1)->width);
46254   jresult = result;
46255   return jresult;
46256 }
46257
46258
46259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46260   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46261   float arg2 ;
46262
46263   arg1 = (Dali::Rect< float > *)jarg1;
46264   arg2 = (float)jarg2;
46265   if (arg1) (arg1)->bottom = arg2;
46266 }
46267
46268
46269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46270   float jresult ;
46271   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46272   float result;
46273
46274   arg1 = (Dali::Rect< float > *)jarg1;
46275   result = (float) ((arg1)->bottom);
46276   jresult = result;
46277   return jresult;
46278 }
46279
46280
46281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46282   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46283   float arg2 ;
46284
46285   arg1 = (Dali::Rect< float > *)jarg1;
46286   arg2 = (float)jarg2;
46287   if (arg1) (arg1)->height = arg2;
46288 }
46289
46290
46291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46292   float jresult ;
46293   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46294   float result;
46295
46296   arg1 = (Dali::Rect< float > *)jarg1;
46297   result = (float) ((arg1)->height);
46298   jresult = result;
46299   return jresult;
46300 }
46301
46302
46303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46304   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46305   float arg2 ;
46306
46307   arg1 = (Dali::Rect< float > *)jarg1;
46308   arg2 = (float)jarg2;
46309   if (arg1) (arg1)->top = arg2;
46310 }
46311
46312
46313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46314   float jresult ;
46315   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46316   float result;
46317
46318   arg1 = (Dali::Rect< float > *)jarg1;
46319   result = (float) ((arg1)->top);
46320   jresult = result;
46321   return jresult;
46322 }
46323
46324
46325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46326   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46327
46328   arg1 = (Dali::Rect< float > *)jarg1;
46329   {
46330     try {
46331       delete arg1;
46332     } catch (std::out_of_range& e) {
46333       {
46334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46335       };
46336     } catch (std::exception& e) {
46337       {
46338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46339       };
46340     } catch (...) {
46341       {
46342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46343       };
46344     }
46345   }
46346 }
46347
46348
46349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46350   int jresult ;
46351   int result;
46352
46353   result = (int)Dali::Vector< int >::BaseType;
46354   jresult = (int)result;
46355   return jresult;
46356 }
46357
46358
46359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46360   void * jresult ;
46361   Dali::Vector< int > *result = 0 ;
46362
46363   {
46364     try {
46365       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46366     } catch (std::out_of_range& e) {
46367       {
46368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46369       };
46370     } catch (std::exception& e) {
46371       {
46372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46373       };
46374     } catch (...) {
46375       {
46376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46377       };
46378     }
46379   }
46380   jresult = (void *)result;
46381   return jresult;
46382 }
46383
46384
46385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46386   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46387
46388   arg1 = (Dali::Vector< int > *)jarg1;
46389   {
46390     try {
46391       delete arg1;
46392     } catch (std::out_of_range& e) {
46393       {
46394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46395       };
46396     } catch (std::exception& e) {
46397       {
46398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46399       };
46400     } catch (...) {
46401       {
46402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46403       };
46404     }
46405   }
46406 }
46407
46408
46409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46410   void * jresult ;
46411   Dali::Vector< int > *arg1 = 0 ;
46412   Dali::Vector< int > *result = 0 ;
46413
46414   arg1 = (Dali::Vector< int > *)jarg1;
46415   if (!arg1) {
46416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46417     return 0;
46418   }
46419   {
46420     try {
46421       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46422     } catch (std::out_of_range& e) {
46423       {
46424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46425       };
46426     } catch (std::exception& e) {
46427       {
46428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46429       };
46430     } catch (...) {
46431       {
46432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46433       };
46434     }
46435   }
46436   jresult = (void *)result;
46437   return jresult;
46438 }
46439
46440
46441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46442   void * jresult ;
46443   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46444   Dali::Vector< int > *arg2 = 0 ;
46445   Dali::Vector< int > *result = 0 ;
46446
46447   arg1 = (Dali::Vector< int > *)jarg1;
46448   arg2 = (Dali::Vector< int > *)jarg2;
46449   if (!arg2) {
46450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46451     return 0;
46452   }
46453   {
46454     try {
46455       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46456     } catch (std::out_of_range& e) {
46457       {
46458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46459       };
46460     } catch (std::exception& e) {
46461       {
46462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46463       };
46464     } catch (...) {
46465       {
46466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46467       };
46468     }
46469   }
46470   jresult = (void *)result;
46471   return jresult;
46472 }
46473
46474
46475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46476   void * jresult ;
46477   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46478   Dali::Vector< int >::Iterator result;
46479
46480   arg1 = (Dali::Vector< int > *)jarg1;
46481   {
46482     try {
46483       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46484     } catch (std::out_of_range& e) {
46485       {
46486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46487       };
46488     } catch (std::exception& e) {
46489       {
46490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46491       };
46492     } catch (...) {
46493       {
46494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46495       };
46496     }
46497   }
46498   jresult = (void *)result;
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46504   void * jresult ;
46505   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46506   Dali::Vector< int >::Iterator result;
46507
46508   arg1 = (Dali::Vector< int > *)jarg1;
46509   {
46510     try {
46511       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46512     } catch (std::out_of_range& e) {
46513       {
46514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46515       };
46516     } catch (std::exception& e) {
46517       {
46518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46519       };
46520     } catch (...) {
46521       {
46522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46523       };
46524     }
46525   }
46526   jresult = (void *)result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46532   void * jresult ;
46533   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46534   Dali::Vector< int >::SizeType arg2 ;
46535   Dali::Vector< int >::ItemType *result = 0 ;
46536
46537   arg1 = (Dali::Vector< int > *)jarg1;
46538   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46539   {
46540     try {
46541       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46542     } catch (std::out_of_range& e) {
46543       {
46544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46545       };
46546     } catch (std::exception& e) {
46547       {
46548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46549       };
46550     } catch (...) {
46551       {
46552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46553       };
46554     }
46555   }
46556   jresult = (void *)result;
46557   return jresult;
46558 }
46559
46560
46561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46562   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46563   Dali::Vector< int >::ItemType *arg2 = 0 ;
46564   Dali::Vector< int >::ItemType temp2 ;
46565
46566   arg1 = (Dali::Vector< int > *)jarg1;
46567   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46568   arg2 = &temp2;
46569   {
46570     try {
46571       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46572     } catch (std::out_of_range& e) {
46573       {
46574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46575       };
46576     } catch (std::exception& e) {
46577       {
46578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46579       };
46580     } catch (...) {
46581       {
46582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46583       };
46584     }
46585   }
46586 }
46587
46588
46589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46590   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46591   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46592   Dali::Vector< int >::ItemType *arg3 = 0 ;
46593   Dali::Vector< int >::ItemType temp3 ;
46594
46595   arg1 = (Dali::Vector< int > *)jarg1;
46596   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46597   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46598   arg3 = &temp3;
46599   {
46600     try {
46601       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46602     } catch (std::out_of_range& e) {
46603       {
46604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46605       };
46606     } catch (std::exception& e) {
46607       {
46608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46609       };
46610     } catch (...) {
46611       {
46612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46613       };
46614     }
46615   }
46616 }
46617
46618
46619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46620   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46621   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46622   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46623   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46624
46625   arg1 = (Dali::Vector< int > *)jarg1;
46626   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46627   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46628   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46629   {
46630     try {
46631       (arg1)->Insert(arg2,arg3,arg4);
46632     } catch (std::out_of_range& e) {
46633       {
46634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46635       };
46636     } catch (std::exception& e) {
46637       {
46638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46639       };
46640     } catch (...) {
46641       {
46642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46643       };
46644     }
46645   }
46646 }
46647
46648
46649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46650   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46651   Dali::Vector< int >::SizeType arg2 ;
46652
46653   arg1 = (Dali::Vector< int > *)jarg1;
46654   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46655   {
46656     try {
46657       (arg1)->Reserve(arg2);
46658     } catch (std::out_of_range& e) {
46659       {
46660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46661       };
46662     } catch (std::exception& e) {
46663       {
46664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46665       };
46666     } catch (...) {
46667       {
46668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46669       };
46670     }
46671   }
46672 }
46673
46674
46675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46676   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46677   Dali::Vector< int >::SizeType arg2 ;
46678
46679   arg1 = (Dali::Vector< int > *)jarg1;
46680   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46681   {
46682     try {
46683       (arg1)->Resize(arg2);
46684     } catch (std::out_of_range& e) {
46685       {
46686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46687       };
46688     } catch (std::exception& e) {
46689       {
46690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46691       };
46692     } catch (...) {
46693       {
46694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46695       };
46696     }
46697   }
46698 }
46699
46700
46701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46702   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46703   Dali::Vector< int >::SizeType arg2 ;
46704   Dali::Vector< int >::ItemType *arg3 = 0 ;
46705   Dali::Vector< int >::ItemType temp3 ;
46706
46707   arg1 = (Dali::Vector< int > *)jarg1;
46708   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46709   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46710   arg3 = &temp3;
46711   {
46712     try {
46713       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46714     } catch (std::out_of_range& e) {
46715       {
46716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46717       };
46718     } catch (std::exception& e) {
46719       {
46720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46721       };
46722     } catch (...) {
46723       {
46724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46725       };
46726     }
46727   }
46728 }
46729
46730
46731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46732   void * jresult ;
46733   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46734   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46735   Dali::Vector< int >::Iterator result;
46736
46737   arg1 = (Dali::Vector< int > *)jarg1;
46738   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46739   {
46740     try {
46741       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46742     } catch (std::out_of_range& e) {
46743       {
46744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (std::exception& e) {
46747       {
46748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46753       };
46754     }
46755   }
46756   jresult = (void *)result;
46757   return jresult;
46758 }
46759
46760
46761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46762   void * jresult ;
46763   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46764   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46765   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46766   Dali::Vector< int >::Iterator result;
46767
46768   arg1 = (Dali::Vector< int > *)jarg1;
46769   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46770   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46771   {
46772     try {
46773       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46774     } catch (std::out_of_range& e) {
46775       {
46776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46777       };
46778     } catch (std::exception& e) {
46779       {
46780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46781       };
46782     } catch (...) {
46783       {
46784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46785       };
46786     }
46787   }
46788   jresult = (void *)result;
46789   return jresult;
46790 }
46791
46792
46793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46795   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46796
46797   arg1 = (Dali::Vector< int > *)jarg1;
46798   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46799   {
46800     try {
46801       (arg1)->Remove(arg2);
46802     } catch (std::out_of_range& e) {
46803       {
46804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46805       };
46806     } catch (std::exception& e) {
46807       {
46808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46809       };
46810     } catch (...) {
46811       {
46812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46813       };
46814     }
46815   }
46816 }
46817
46818
46819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46820   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46821   Dali::Vector< int > *arg2 = 0 ;
46822
46823   arg1 = (Dali::Vector< int > *)jarg1;
46824   arg2 = (Dali::Vector< int > *)jarg2;
46825   if (!arg2) {
46826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46827     return ;
46828   }
46829   {
46830     try {
46831       (arg1)->Swap(*arg2);
46832     } catch (std::out_of_range& e) {
46833       {
46834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46835       };
46836     } catch (std::exception& e) {
46837       {
46838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46839       };
46840     } catch (...) {
46841       {
46842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46843       };
46844     }
46845   }
46846 }
46847
46848
46849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46850   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46851
46852   arg1 = (Dali::Vector< int > *)jarg1;
46853   {
46854     try {
46855       (arg1)->Clear();
46856     } catch (std::out_of_range& e) {
46857       {
46858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46859       };
46860     } catch (std::exception& e) {
46861       {
46862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46863       };
46864     } catch (...) {
46865       {
46866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46867       };
46868     }
46869   }
46870 }
46871
46872
46873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46874   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46875
46876   arg1 = (Dali::Vector< int > *)jarg1;
46877   {
46878     try {
46879       (arg1)->Release();
46880     } catch (std::out_of_range& e) {
46881       {
46882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46883       };
46884     } catch (std::exception& e) {
46885       {
46886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46887       };
46888     } catch (...) {
46889       {
46890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46891       };
46892     }
46893   }
46894 }
46895
46896
46897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46898   int jresult ;
46899   int result;
46900
46901   result = (int)Dali::Vector< float >::BaseType;
46902   jresult = (int)result;
46903   return jresult;
46904 }
46905
46906
46907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46908   void * jresult ;
46909   Dali::Vector< float > *result = 0 ;
46910
46911   {
46912     try {
46913       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46914     } catch (std::out_of_range& e) {
46915       {
46916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46917       };
46918     } catch (std::exception& e) {
46919       {
46920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46921       };
46922     } catch (...) {
46923       {
46924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46925       };
46926     }
46927   }
46928   jresult = (void *)result;
46929   return jresult;
46930 }
46931
46932
46933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46935
46936   arg1 = (Dali::Vector< float > *)jarg1;
46937   {
46938     try {
46939       delete arg1;
46940     } catch (std::out_of_range& e) {
46941       {
46942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46943       };
46944     } catch (std::exception& e) {
46945       {
46946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46947       };
46948     } catch (...) {
46949       {
46950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46951       };
46952     }
46953   }
46954 }
46955
46956
46957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46958   void * jresult ;
46959   Dali::Vector< float > *arg1 = 0 ;
46960   Dali::Vector< float > *result = 0 ;
46961
46962   arg1 = (Dali::Vector< float > *)jarg1;
46963   if (!arg1) {
46964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46965     return 0;
46966   }
46967   {
46968     try {
46969       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46970     } catch (std::out_of_range& e) {
46971       {
46972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46973       };
46974     } catch (std::exception& e) {
46975       {
46976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46981       };
46982     }
46983   }
46984   jresult = (void *)result;
46985   return jresult;
46986 }
46987
46988
46989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46990   void * jresult ;
46991   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46992   Dali::Vector< float > *arg2 = 0 ;
46993   Dali::Vector< float > *result = 0 ;
46994
46995   arg1 = (Dali::Vector< float > *)jarg1;
46996   arg2 = (Dali::Vector< float > *)jarg2;
46997   if (!arg2) {
46998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46999     return 0;
47000   }
47001   {
47002     try {
47003       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47004     } catch (std::out_of_range& e) {
47005       {
47006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47007       };
47008     } catch (std::exception& e) {
47009       {
47010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47011       };
47012     } catch (...) {
47013       {
47014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47015       };
47016     }
47017   }
47018   jresult = (void *)result;
47019   return jresult;
47020 }
47021
47022
47023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47024   void * jresult ;
47025   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47026   Dali::Vector< float >::Iterator result;
47027
47028   arg1 = (Dali::Vector< float > *)jarg1;
47029   {
47030     try {
47031       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47032     } catch (std::out_of_range& e) {
47033       {
47034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47035       };
47036     } catch (std::exception& e) {
47037       {
47038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47039       };
47040     } catch (...) {
47041       {
47042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47043       };
47044     }
47045   }
47046   jresult = (void *)result;
47047   return jresult;
47048 }
47049
47050
47051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47052   void * jresult ;
47053   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47054   Dali::Vector< float >::Iterator result;
47055
47056   arg1 = (Dali::Vector< float > *)jarg1;
47057   {
47058     try {
47059       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47060     } catch (std::out_of_range& e) {
47061       {
47062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47063       };
47064     } catch (std::exception& e) {
47065       {
47066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47067       };
47068     } catch (...) {
47069       {
47070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47071       };
47072     }
47073   }
47074   jresult = (void *)result;
47075   return jresult;
47076 }
47077
47078
47079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47080   void * jresult ;
47081   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47082   Dali::Vector< float >::SizeType arg2 ;
47083   Dali::Vector< float >::ItemType *result = 0 ;
47084
47085   arg1 = (Dali::Vector< float > *)jarg1;
47086   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47087   {
47088     try {
47089       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47090     } catch (std::out_of_range& e) {
47091       {
47092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47093       };
47094     } catch (std::exception& e) {
47095       {
47096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47097       };
47098     } catch (...) {
47099       {
47100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47101       };
47102     }
47103   }
47104   jresult = (void *)result;
47105   return jresult;
47106 }
47107
47108
47109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47110   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47111   Dali::Vector< float >::ItemType *arg2 = 0 ;
47112   Dali::Vector< float >::ItemType temp2 ;
47113
47114   arg1 = (Dali::Vector< float > *)jarg1;
47115   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47116   arg2 = &temp2;
47117   {
47118     try {
47119       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47120     } catch (std::out_of_range& e) {
47121       {
47122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47123       };
47124     } catch (std::exception& e) {
47125       {
47126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47127       };
47128     } catch (...) {
47129       {
47130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47131       };
47132     }
47133   }
47134 }
47135
47136
47137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47138   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47139   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47140   Dali::Vector< float >::ItemType *arg3 = 0 ;
47141   Dali::Vector< float >::ItemType temp3 ;
47142
47143   arg1 = (Dali::Vector< float > *)jarg1;
47144   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47145   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47146   arg3 = &temp3;
47147   {
47148     try {
47149       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47150     } catch (std::out_of_range& e) {
47151       {
47152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47153       };
47154     } catch (std::exception& e) {
47155       {
47156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47157       };
47158     } catch (...) {
47159       {
47160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47161       };
47162     }
47163   }
47164 }
47165
47166
47167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47168   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47169   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47170   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47171   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47172
47173   arg1 = (Dali::Vector< float > *)jarg1;
47174   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47175   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47176   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47177   {
47178     try {
47179       (arg1)->Insert(arg2,arg3,arg4);
47180     } catch (std::out_of_range& e) {
47181       {
47182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47183       };
47184     } catch (std::exception& e) {
47185       {
47186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47187       };
47188     } catch (...) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47191       };
47192     }
47193   }
47194 }
47195
47196
47197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47198   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47199   Dali::Vector< float >::SizeType arg2 ;
47200
47201   arg1 = (Dali::Vector< float > *)jarg1;
47202   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47203   {
47204     try {
47205       (arg1)->Reserve(arg2);
47206     } catch (std::out_of_range& e) {
47207       {
47208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47209       };
47210     } catch (std::exception& e) {
47211       {
47212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47213       };
47214     } catch (...) {
47215       {
47216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47217       };
47218     }
47219   }
47220 }
47221
47222
47223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47224   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47225   Dali::Vector< float >::SizeType arg2 ;
47226
47227   arg1 = (Dali::Vector< float > *)jarg1;
47228   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47229   {
47230     try {
47231       (arg1)->Resize(arg2);
47232     } catch (std::out_of_range& e) {
47233       {
47234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47235       };
47236     } catch (std::exception& e) {
47237       {
47238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47239       };
47240     } catch (...) {
47241       {
47242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47243       };
47244     }
47245   }
47246 }
47247
47248
47249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47250   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47251   Dali::Vector< float >::SizeType arg2 ;
47252   Dali::Vector< float >::ItemType *arg3 = 0 ;
47253   Dali::Vector< float >::ItemType temp3 ;
47254
47255   arg1 = (Dali::Vector< float > *)jarg1;
47256   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47257   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47258   arg3 = &temp3;
47259   {
47260     try {
47261       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47262     } catch (std::out_of_range& e) {
47263       {
47264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47265       };
47266     } catch (std::exception& e) {
47267       {
47268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47269       };
47270     } catch (...) {
47271       {
47272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47273       };
47274     }
47275   }
47276 }
47277
47278
47279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47280   void * jresult ;
47281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47282   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47283   Dali::Vector< float >::Iterator result;
47284
47285   arg1 = (Dali::Vector< float > *)jarg1;
47286   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47287   {
47288     try {
47289       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47290     } catch (std::out_of_range& e) {
47291       {
47292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47293       };
47294     } catch (std::exception& e) {
47295       {
47296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47297       };
47298     } catch (...) {
47299       {
47300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47301       };
47302     }
47303   }
47304   jresult = (void *)result;
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47310   void * jresult ;
47311   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47312   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47313   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47314   Dali::Vector< float >::Iterator result;
47315
47316   arg1 = (Dali::Vector< float > *)jarg1;
47317   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47318   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47319   {
47320     try {
47321       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47322     } catch (std::out_of_range& e) {
47323       {
47324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (std::exception& e) {
47327       {
47328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47329       };
47330     } catch (...) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47333       };
47334     }
47335   }
47336   jresult = (void *)result;
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47342   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47343   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47344
47345   arg1 = (Dali::Vector< float > *)jarg1;
47346   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47347   {
47348     try {
47349       (arg1)->Remove(arg2);
47350     } catch (std::out_of_range& e) {
47351       {
47352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47353       };
47354     } catch (std::exception& e) {
47355       {
47356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47357       };
47358     } catch (...) {
47359       {
47360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47361       };
47362     }
47363   }
47364 }
47365
47366
47367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47368   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47369   Dali::Vector< float > *arg2 = 0 ;
47370
47371   arg1 = (Dali::Vector< float > *)jarg1;
47372   arg2 = (Dali::Vector< float > *)jarg2;
47373   if (!arg2) {
47374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47375     return ;
47376   }
47377   {
47378     try {
47379       (arg1)->Swap(*arg2);
47380     } catch (std::out_of_range& e) {
47381       {
47382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47383       };
47384     } catch (std::exception& e) {
47385       {
47386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (...) {
47389       {
47390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47391       };
47392     }
47393   }
47394 }
47395
47396
47397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47398   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47399
47400   arg1 = (Dali::Vector< float > *)jarg1;
47401   {
47402     try {
47403       (arg1)->Clear();
47404     } catch (std::out_of_range& e) {
47405       {
47406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47407       };
47408     } catch (std::exception& e) {
47409       {
47410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47411       };
47412     } catch (...) {
47413       {
47414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47415       };
47416     }
47417   }
47418 }
47419
47420
47421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47422   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47423
47424   arg1 = (Dali::Vector< float > *)jarg1;
47425   {
47426     try {
47427       (arg1)->Release();
47428     } catch (std::out_of_range& e) {
47429       {
47430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47431       };
47432     } catch (std::exception& e) {
47433       {
47434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47435       };
47436     } catch (...) {
47437       {
47438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47439       };
47440     }
47441   }
47442 }
47443
47444
47445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47446   int jresult ;
47447   int result;
47448
47449   result = (int)Dali::Vector< unsigned char >::BaseType;
47450   jresult = (int)result;
47451   return jresult;
47452 }
47453
47454
47455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47456   void * jresult ;
47457   Dali::Vector< unsigned char > *result = 0 ;
47458
47459   {
47460     try {
47461       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47462     } catch (std::out_of_range& e) {
47463       {
47464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (std::exception& e) {
47467       {
47468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47469       };
47470     } catch (...) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47473       };
47474     }
47475   }
47476   jresult = (void *)result;
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47482   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47483
47484   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47485   {
47486     try {
47487       delete arg1;
47488     } catch (std::out_of_range& e) {
47489       {
47490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47491       };
47492     } catch (std::exception& e) {
47493       {
47494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47495       };
47496     } catch (...) {
47497       {
47498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47499       };
47500     }
47501   }
47502 }
47503
47504
47505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47506   void * jresult ;
47507   Dali::Vector< unsigned char > *arg1 = 0 ;
47508   Dali::Vector< unsigned char > *result = 0 ;
47509
47510   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47511   if (!arg1) {
47512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47513     return 0;
47514   }
47515   {
47516     try {
47517       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47518     } catch (std::out_of_range& e) {
47519       {
47520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47521       };
47522     } catch (std::exception& e) {
47523       {
47524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47525       };
47526     } catch (...) {
47527       {
47528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47529       };
47530     }
47531   }
47532   jresult = (void *)result;
47533   return jresult;
47534 }
47535
47536
47537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47538   void * jresult ;
47539   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47540   Dali::Vector< unsigned char > *arg2 = 0 ;
47541   Dali::Vector< unsigned char > *result = 0 ;
47542
47543   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47544   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47545   if (!arg2) {
47546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47547     return 0;
47548   }
47549   {
47550     try {
47551       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47552     } catch (std::out_of_range& e) {
47553       {
47554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47555       };
47556     } catch (std::exception& e) {
47557       {
47558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47559       };
47560     } catch (...) {
47561       {
47562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47563       };
47564     }
47565   }
47566   jresult = (void *)result;
47567   return jresult;
47568 }
47569
47570
47571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47572   void * jresult ;
47573   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47574   Dali::Vector< unsigned char >::Iterator result;
47575
47576   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47577   {
47578     try {
47579       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47580     } catch (std::out_of_range& e) {
47581       {
47582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47583       };
47584     } catch (std::exception& e) {
47585       {
47586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47587       };
47588     } catch (...) {
47589       {
47590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47591       };
47592     }
47593   }
47594   jresult = (void *)result;
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47600   void * jresult ;
47601   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47602   Dali::Vector< unsigned char >::Iterator result;
47603
47604   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47605   {
47606     try {
47607       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47608     } catch (std::out_of_range& e) {
47609       {
47610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47611       };
47612     } catch (std::exception& e) {
47613       {
47614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47615       };
47616     } catch (...) {
47617       {
47618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47619       };
47620     }
47621   }
47622   jresult = (void *)result;
47623   return jresult;
47624 }
47625
47626
47627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47628   void * jresult ;
47629   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47630   Dali::Vector< unsigned char >::SizeType arg2 ;
47631   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47632
47633   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47634   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47635   {
47636     try {
47637       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47638     } catch (std::out_of_range& e) {
47639       {
47640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47641       };
47642     } catch (std::exception& e) {
47643       {
47644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47645       };
47646     } catch (...) {
47647       {
47648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47649       };
47650     }
47651   }
47652   jresult = (void *)result;
47653   return jresult;
47654 }
47655
47656
47657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47658   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47659   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47660   Dali::Vector< unsigned char >::ItemType temp2 ;
47661
47662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47663   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47664   arg2 = &temp2;
47665   {
47666     try {
47667       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47675       };
47676     } catch (...) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47679       };
47680     }
47681   }
47682 }
47683
47684
47685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47686   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47687   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47688   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47689   Dali::Vector< unsigned char >::ItemType temp3 ;
47690
47691   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47692   arg2 = jarg2;
47693   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47694   arg3 = &temp3;
47695   {
47696     try {
47697       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47698     } catch (std::out_of_range& e) {
47699       {
47700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47701       };
47702     } catch (std::exception& e) {
47703       {
47704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47705       };
47706     } catch (...) {
47707       {
47708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47709       };
47710     }
47711   }
47712
47713
47714 }
47715
47716
47717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47718   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47719   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47720   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47721   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47722
47723   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47724   arg2 = jarg2;
47725   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47726   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47727   {
47728     try {
47729       (arg1)->Insert(arg2,arg3,arg4);
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47737       };
47738     } catch (...) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47741       };
47742     }
47743   }
47744
47745
47746 }
47747
47748
47749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47750   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47751   Dali::Vector< unsigned char >::SizeType arg2 ;
47752
47753   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47754   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47755   {
47756     try {
47757       (arg1)->Reserve(arg2);
47758     } catch (std::out_of_range& e) {
47759       {
47760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47761       };
47762     } catch (std::exception& e) {
47763       {
47764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47765       };
47766     } catch (...) {
47767       {
47768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47769       };
47770     }
47771   }
47772 }
47773
47774
47775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47776   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47777   Dali::Vector< unsigned char >::SizeType arg2 ;
47778
47779   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47780   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47781   {
47782     try {
47783       (arg1)->Resize(arg2);
47784     } catch (std::out_of_range& e) {
47785       {
47786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47787       };
47788     } catch (std::exception& e) {
47789       {
47790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47791       };
47792     } catch (...) {
47793       {
47794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47795       };
47796     }
47797   }
47798 }
47799
47800
47801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47802   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47803   Dali::Vector< unsigned char >::SizeType arg2 ;
47804   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47805   Dali::Vector< unsigned char >::ItemType temp3 ;
47806
47807   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47808   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47809   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47810   arg3 = &temp3;
47811   {
47812     try {
47813       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47814     } catch (std::out_of_range& e) {
47815       {
47816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47817       };
47818     } catch (std::exception& e) {
47819       {
47820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47821       };
47822     } catch (...) {
47823       {
47824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47825       };
47826     }
47827   }
47828 }
47829
47830
47831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47832   void * jresult ;
47833   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47834   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47835   Dali::Vector< unsigned char >::Iterator result;
47836
47837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47838   arg2 = jarg2;
47839   {
47840     try {
47841       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47842     } catch (std::out_of_range& e) {
47843       {
47844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47845       };
47846     } catch (std::exception& e) {
47847       {
47848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47849       };
47850     } catch (...) {
47851       {
47852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47853       };
47854     }
47855   }
47856   jresult = (void *)result;
47857
47858
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47864   void * jresult ;
47865   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47866   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47867   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47868   Dali::Vector< unsigned char >::Iterator result;
47869
47870   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47871   arg2 = jarg2;
47872   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47873   {
47874     try {
47875       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47887       };
47888     }
47889   }
47890   jresult = (void *)result;
47891
47892
47893   return jresult;
47894 }
47895
47896
47897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47898   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47899   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47900
47901   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47902   arg2 = jarg2;
47903   {
47904     try {
47905       (arg1)->Remove(arg2);
47906     } catch (std::out_of_range& e) {
47907       {
47908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47909       };
47910     } catch (std::exception& e) {
47911       {
47912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47913       };
47914     } catch (...) {
47915       {
47916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47917       };
47918     }
47919   }
47920
47921
47922 }
47923
47924
47925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47926   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47927   Dali::Vector< unsigned char > *arg2 = 0 ;
47928
47929   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47930   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47931   if (!arg2) {
47932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47933     return ;
47934   }
47935   {
47936     try {
47937       (arg1)->Swap(*arg2);
47938     } catch (std::out_of_range& e) {
47939       {
47940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47941       };
47942     } catch (std::exception& e) {
47943       {
47944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47945       };
47946     } catch (...) {
47947       {
47948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47949       };
47950     }
47951   }
47952 }
47953
47954
47955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47956   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47957
47958   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47959   {
47960     try {
47961       (arg1)->Clear();
47962     } catch (std::out_of_range& e) {
47963       {
47964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (std::exception& e) {
47967       {
47968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47969       };
47970     } catch (...) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47973       };
47974     }
47975   }
47976 }
47977
47978
47979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47980   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47981
47982   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47983   {
47984     try {
47985       (arg1)->Release();
47986     } catch (std::out_of_range& e) {
47987       {
47988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47989       };
47990     } catch (std::exception& e) {
47991       {
47992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47993       };
47994     } catch (...) {
47995       {
47996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47997       };
47998     }
47999   }
48000 }
48001
48002
48003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48004   int jresult ;
48005   int result;
48006
48007   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48008   jresult = (int)result;
48009   return jresult;
48010 }
48011
48012
48013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48014   void * jresult ;
48015   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48016
48017   {
48018     try {
48019       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48020     } catch (std::out_of_range& e) {
48021       {
48022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48023       };
48024     } catch (std::exception& e) {
48025       {
48026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48027       };
48028     } catch (...) {
48029       {
48030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48031       };
48032     }
48033   }
48034   jresult = (void *)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48040   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48041
48042   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48043   {
48044     try {
48045       delete arg1;
48046     } catch (std::out_of_range& e) {
48047       {
48048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48049       };
48050     } catch (std::exception& e) {
48051       {
48052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48053       };
48054     } catch (...) {
48055       {
48056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48057       };
48058     }
48059   }
48060 }
48061
48062
48063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48064   void * jresult ;
48065   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48066   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48067
48068   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48069   if (!arg1) {
48070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48071     return 0;
48072   }
48073   {
48074     try {
48075       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48076     } catch (std::out_of_range& e) {
48077       {
48078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48079       };
48080     } catch (std::exception& e) {
48081       {
48082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48083       };
48084     } catch (...) {
48085       {
48086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48087       };
48088     }
48089   }
48090   jresult = (void *)result;
48091   return jresult;
48092 }
48093
48094
48095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48096   void * jresult ;
48097   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48098   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48099   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48100
48101   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48102   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48103   if (!arg2) {
48104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48105     return 0;
48106   }
48107   {
48108     try {
48109       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48110     } catch (std::out_of_range& e) {
48111       {
48112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48113       };
48114     } catch (std::exception& e) {
48115       {
48116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48117       };
48118     } catch (...) {
48119       {
48120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48121       };
48122     }
48123   }
48124   jresult = (void *)result;
48125   return jresult;
48126 }
48127
48128
48129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48130   void * jresult ;
48131   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48132   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48133
48134   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48135   {
48136     try {
48137       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48138     } catch (std::out_of_range& e) {
48139       {
48140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48141       };
48142     } catch (std::exception& e) {
48143       {
48144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (...) {
48147       {
48148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48149       };
48150     }
48151   }
48152   jresult = (void *)result;
48153   return jresult;
48154 }
48155
48156
48157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48158   void * jresult ;
48159   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48160   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48161
48162   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48163   {
48164     try {
48165       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48166     } catch (std::out_of_range& e) {
48167       {
48168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48169       };
48170     } catch (std::exception& e) {
48171       {
48172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48173       };
48174     } catch (...) {
48175       {
48176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48177       };
48178     }
48179   }
48180   jresult = (void *)result;
48181   return jresult;
48182 }
48183
48184
48185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48186   void * jresult ;
48187   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48188   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48189   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48190
48191   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48192   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48193   {
48194     try {
48195       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48196     } catch (std::out_of_range& e) {
48197       {
48198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (std::exception& e) {
48201       {
48202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48203       };
48204     } catch (...) {
48205       {
48206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48207       };
48208     }
48209   }
48210   jresult = (void *)result;
48211   return jresult;
48212 }
48213
48214
48215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48216   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48217   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48218
48219   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48220   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48221   if (!arg2) {
48222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48223     return ;
48224   }
48225   {
48226     try {
48227       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48228     } catch (std::out_of_range& e) {
48229       {
48230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48231       };
48232     } catch (std::exception& e) {
48233       {
48234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48235       };
48236     } catch (...) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48239       };
48240     }
48241   }
48242 }
48243
48244
48245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48246   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48247   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48248   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48249
48250   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48251   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48252   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48253   if (!arg3) {
48254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48255     return ;
48256   }
48257   {
48258     try {
48259       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48260     } catch (std::out_of_range& e) {
48261       {
48262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48263       };
48264     } catch (std::exception& e) {
48265       {
48266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48267       };
48268     } catch (...) {
48269       {
48270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48271       };
48272     }
48273   }
48274 }
48275
48276
48277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48278   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48279   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48280   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48281   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48282
48283   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48284   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48285   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48286   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48287   {
48288     try {
48289       (arg1)->Insert(arg2,arg3,arg4);
48290     } catch (std::out_of_range& e) {
48291       {
48292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48293       };
48294     } catch (std::exception& e) {
48295       {
48296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48297       };
48298     } catch (...) {
48299       {
48300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48301       };
48302     }
48303   }
48304 }
48305
48306
48307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48308   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48309   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48310
48311   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48312   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48313   {
48314     try {
48315       (arg1)->Reserve(arg2);
48316     } catch (std::out_of_range& e) {
48317       {
48318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48319       };
48320     } catch (std::exception& e) {
48321       {
48322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48323       };
48324     } catch (...) {
48325       {
48326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48327       };
48328     }
48329   }
48330 }
48331
48332
48333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48334   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48335   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48336
48337   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48338   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48339   {
48340     try {
48341       (arg1)->Resize(arg2);
48342     } catch (std::out_of_range& e) {
48343       {
48344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48345       };
48346     } catch (std::exception& e) {
48347       {
48348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48349       };
48350     } catch (...) {
48351       {
48352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48353       };
48354     }
48355   }
48356 }
48357
48358
48359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48360   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48361   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48362   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48363
48364   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48365   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48366   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48367   if (!arg3) {
48368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48369     return ;
48370   }
48371   {
48372     try {
48373       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48374     } catch (std::out_of_range& e) {
48375       {
48376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48377       };
48378     } catch (std::exception& e) {
48379       {
48380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48385       };
48386     }
48387   }
48388 }
48389
48390
48391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48392   void * jresult ;
48393   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48394   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48395   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48396
48397   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48398   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48399   {
48400     try {
48401       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48402     } catch (std::out_of_range& e) {
48403       {
48404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48405       };
48406     } catch (std::exception& e) {
48407       {
48408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48409       };
48410     } catch (...) {
48411       {
48412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48413       };
48414     }
48415   }
48416   jresult = (void *)result;
48417   return jresult;
48418 }
48419
48420
48421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48422   void * jresult ;
48423   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48424   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48425   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48426   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48427
48428   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48429   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48430   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48431   {
48432     try {
48433       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48434     } catch (std::out_of_range& e) {
48435       {
48436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48437       };
48438     } catch (std::exception& e) {
48439       {
48440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48441       };
48442     } catch (...) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48445       };
48446     }
48447   }
48448   jresult = (void *)result;
48449   return jresult;
48450 }
48451
48452
48453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48454   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48455   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48456
48457   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48458   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48459   {
48460     try {
48461       (arg1)->Remove(arg2);
48462     } catch (std::out_of_range& e) {
48463       {
48464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48465       };
48466     } catch (std::exception& e) {
48467       {
48468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48469       };
48470     } catch (...) {
48471       {
48472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48473       };
48474     }
48475   }
48476 }
48477
48478
48479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48480   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48481   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48482
48483   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48484   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48485   if (!arg2) {
48486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48487     return ;
48488   }
48489   {
48490     try {
48491       (arg1)->Swap(*arg2);
48492     } catch (std::out_of_range& e) {
48493       {
48494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48495       };
48496     } catch (std::exception& e) {
48497       {
48498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48499       };
48500     } catch (...) {
48501       {
48502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48503       };
48504     }
48505   }
48506 }
48507
48508
48509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48510   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48511
48512   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48513   {
48514     try {
48515       (arg1)->Clear();
48516     } catch (std::out_of_range& e) {
48517       {
48518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48519       };
48520     } catch (std::exception& e) {
48521       {
48522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48523       };
48524     } catch (...) {
48525       {
48526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48527       };
48528     }
48529   }
48530 }
48531
48532
48533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48534   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48535
48536   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48537   {
48538     try {
48539       (arg1)->Release();
48540     } catch (std::out_of_range& e) {
48541       {
48542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48543       };
48544     } catch (std::exception& e) {
48545       {
48546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48547       };
48548     } catch (...) {
48549       {
48550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48551       };
48552     }
48553   }
48554 }
48555
48556
48557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48558   void * jresult ;
48559   Dali::Signal< void () > *result = 0 ;
48560
48561   {
48562     try {
48563       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48564     } catch (std::out_of_range& e) {
48565       {
48566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48567       };
48568     } catch (std::exception& e) {
48569       {
48570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48571       };
48572     } catch (...) {
48573       {
48574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48575       };
48576     }
48577   }
48578   jresult = (void *)result;
48579   return jresult;
48580 }
48581
48582
48583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48584   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48585
48586   arg1 = (Dali::Signal< void () > *)jarg1;
48587   {
48588     try {
48589       delete arg1;
48590     } catch (std::out_of_range& e) {
48591       {
48592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48593       };
48594     } catch (std::exception& e) {
48595       {
48596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48597       };
48598     } catch (...) {
48599       {
48600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48601       };
48602     }
48603   }
48604 }
48605
48606
48607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48608   unsigned int jresult ;
48609   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48610   bool result;
48611
48612   arg1 = (Dali::Signal< void () > *)jarg1;
48613   {
48614     try {
48615       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48627       };
48628     }
48629   }
48630   jresult = result;
48631   return jresult;
48632 }
48633
48634
48635 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48636   unsigned long jresult ;
48637   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48638   std::size_t result;
48639
48640   arg1 = (Dali::Signal< void () > *)jarg1;
48641   {
48642     try {
48643       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48644     } catch (std::out_of_range& e) {
48645       {
48646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48647       };
48648     } catch (std::exception& e) {
48649       {
48650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48655       };
48656     }
48657   }
48658   jresult = (unsigned long)result;
48659   return jresult;
48660 }
48661
48662
48663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48664   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48665   void (*arg2)() = (void (*)()) 0 ;
48666
48667   arg1 = (Dali::Signal< void () > *)jarg1;
48668   arg2 = (void (*)())jarg2;
48669   {
48670     try {
48671       (arg1)->Connect(arg2);
48672     } catch (std::out_of_range& e) {
48673       {
48674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48675       };
48676     } catch (std::exception& e) {
48677       {
48678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (...) {
48681       {
48682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48683       };
48684     }
48685   }
48686 }
48687
48688
48689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48690   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48691   void (*arg2)() = (void (*)()) 0 ;
48692
48693   arg1 = (Dali::Signal< void () > *)jarg1;
48694   arg2 = (void (*)())jarg2;
48695   {
48696     try {
48697       (arg1)->Disconnect(arg2);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (...) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48709       };
48710     }
48711   }
48712 }
48713
48714
48715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48716   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48717   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48718   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48719
48720   arg1 = (Dali::Signal< void () > *)jarg1;
48721   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48722   arg3 = (Dali::FunctorDelegate *)jarg3;
48723   {
48724     try {
48725       (arg1)->Connect(arg2,arg3);
48726     } catch (std::out_of_range& e) {
48727       {
48728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48729       };
48730     } catch (std::exception& e) {
48731       {
48732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48733       };
48734     } catch (...) {
48735       {
48736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48737       };
48738     }
48739   }
48740 }
48741
48742
48743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48744   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48745
48746   arg1 = (Dali::Signal< void () > *)jarg1;
48747   {
48748     try {
48749       (arg1)->Emit();
48750     } catch (std::out_of_range& e) {
48751       {
48752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48753       };
48754     } catch (std::exception& e) {
48755       {
48756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48757       };
48758     } catch (...) {
48759       {
48760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48761       };
48762     }
48763   }
48764 }
48765
48766
48767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48768   unsigned int jresult ;
48769   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48770   bool result;
48771
48772   arg1 = (Dali::Signal< void (float) > *)jarg1;
48773   {
48774     try {
48775       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48776     } catch (std::out_of_range& e) {
48777       {
48778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48779       };
48780     } catch (std::exception& e) {
48781       {
48782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48783       };
48784     } catch (...) {
48785       {
48786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48787       };
48788     }
48789   }
48790   jresult = result;
48791   return jresult;
48792 }
48793
48794
48795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48796   unsigned long jresult ;
48797   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48798   std::size_t result;
48799
48800   arg1 = (Dali::Signal< void (float) > *)jarg1;
48801   {
48802     try {
48803       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48804     } catch (std::out_of_range& e) {
48805       {
48806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48807       };
48808     } catch (std::exception& e) {
48809       {
48810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (...) {
48813       {
48814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48815       };
48816     }
48817   }
48818   jresult = (unsigned long)result;
48819   return jresult;
48820 }
48821
48822
48823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48824   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48825   void (*arg2)(float) = (void (*)(float)) 0 ;
48826
48827   arg1 = (Dali::Signal< void (float) > *)jarg1;
48828   arg2 = (void (*)(float))jarg2;
48829   {
48830     try {
48831       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48832     } catch (std::out_of_range& e) {
48833       {
48834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48835       };
48836     } catch (std::exception& e) {
48837       {
48838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (...) {
48841       {
48842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48843       };
48844     }
48845   }
48846 }
48847
48848
48849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48850   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48851   void (*arg2)(float) = (void (*)(float)) 0 ;
48852
48853   arg1 = (Dali::Signal< void (float) > *)jarg1;
48854   arg2 = (void (*)(float))jarg2;
48855   {
48856     try {
48857       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48858     } catch (std::out_of_range& e) {
48859       {
48860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48861       };
48862     } catch (std::exception& e) {
48863       {
48864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48865       };
48866     } catch (...) {
48867       {
48868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48869       };
48870     }
48871   }
48872 }
48873
48874
48875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48876   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48877   float arg2 ;
48878
48879   arg1 = (Dali::Signal< void (float) > *)jarg1;
48880   arg2 = (float)jarg2;
48881   {
48882     try {
48883       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48884     } catch (std::out_of_range& e) {
48885       {
48886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48887       };
48888     } catch (std::exception& e) {
48889       {
48890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48891       };
48892     } catch (...) {
48893       {
48894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48895       };
48896     }
48897   }
48898 }
48899
48900
48901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48902   void * jresult ;
48903   Dali::Signal< void (float) > *result = 0 ;
48904
48905   {
48906     try {
48907       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48908     } catch (std::out_of_range& e) {
48909       {
48910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48911       };
48912     } catch (std::exception& e) {
48913       {
48914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48915       };
48916     } catch (...) {
48917       {
48918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48919       };
48920     }
48921   }
48922   jresult = (void *)result;
48923   return jresult;
48924 }
48925
48926
48927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48928   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48929
48930   arg1 = (Dali::Signal< void (float) > *)jarg1;
48931   {
48932     try {
48933       delete arg1;
48934     } catch (std::out_of_range& e) {
48935       {
48936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48937       };
48938     } catch (std::exception& e) {
48939       {
48940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48941       };
48942     } catch (...) {
48943       {
48944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48945       };
48946     }
48947   }
48948 }
48949
48950
48951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48952   unsigned int jresult ;
48953   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48954   bool result;
48955
48956   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48957   {
48958     try {
48959       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48960     } catch (std::out_of_range& e) {
48961       {
48962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48963       };
48964     } catch (std::exception& e) {
48965       {
48966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48967       };
48968     } catch (...) {
48969       {
48970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48971       };
48972     }
48973   }
48974   jresult = result;
48975   return jresult;
48976 }
48977
48978
48979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48980   unsigned long jresult ;
48981   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48982   std::size_t result;
48983
48984   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48985   {
48986     try {
48987       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48988     } catch (std::out_of_range& e) {
48989       {
48990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48991       };
48992     } catch (std::exception& e) {
48993       {
48994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48995       };
48996     } catch (...) {
48997       {
48998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48999       };
49000     }
49001   }
49002   jresult = (unsigned long)result;
49003   return jresult;
49004 }
49005
49006
49007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49008   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49009   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49010
49011   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49012   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49013   {
49014     try {
49015       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49016     } catch (std::out_of_range& e) {
49017       {
49018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49019       };
49020     } catch (std::exception& e) {
49021       {
49022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49023       };
49024     } catch (...) {
49025       {
49026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49027       };
49028     }
49029   }
49030 }
49031
49032
49033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49034   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49035   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49036
49037   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49038   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49039   {
49040     try {
49041       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49042     } catch (std::out_of_range& e) {
49043       {
49044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (std::exception& e) {
49047       {
49048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49049       };
49050     } catch (...) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49053       };
49054     }
49055   }
49056 }
49057
49058
49059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49060   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49061   Dali::BaseHandle arg2 ;
49062   Dali::BaseHandle *argp2 ;
49063
49064   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49065   argp2 = (Dali::BaseHandle *)jarg2;
49066   if (!argp2) {
49067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49068     return ;
49069   }
49070   arg2 = *argp2;
49071   {
49072     try {
49073       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49074     } catch (std::out_of_range& e) {
49075       {
49076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49077       };
49078     } catch (std::exception& e) {
49079       {
49080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49081       };
49082     } catch (...) {
49083       {
49084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49085       };
49086     }
49087   }
49088 }
49089
49090
49091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49092   void * jresult ;
49093   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49094
49095   {
49096     try {
49097       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49098     } catch (std::out_of_range& e) {
49099       {
49100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49101       };
49102     } catch (std::exception& e) {
49103       {
49104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49105       };
49106     } catch (...) {
49107       {
49108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49109       };
49110     }
49111   }
49112   jresult = (void *)result;
49113   return jresult;
49114 }
49115
49116
49117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49118   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49119
49120   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49121   {
49122     try {
49123       delete arg1;
49124     } catch (std::out_of_range& e) {
49125       {
49126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49127       };
49128     } catch (std::exception& e) {
49129       {
49130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49131       };
49132     } catch (...) {
49133       {
49134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49135       };
49136     }
49137   }
49138 }
49139
49140
49141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49142   unsigned int jresult ;
49143   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49144   bool result;
49145
49146   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49147   {
49148     try {
49149       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49150     } catch (std::out_of_range& e) {
49151       {
49152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49153       };
49154     } catch (std::exception& e) {
49155       {
49156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49161       };
49162     }
49163   }
49164   jresult = result;
49165   return jresult;
49166 }
49167
49168
49169 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49170   unsigned long jresult ;
49171   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49172   std::size_t result;
49173
49174   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49175   {
49176     try {
49177       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49178     } catch (std::out_of_range& e) {
49179       {
49180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49181       };
49182     } catch (std::exception& e) {
49183       {
49184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49185       };
49186     } catch (...) {
49187       {
49188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49189       };
49190     }
49191   }
49192   jresult = (unsigned long)result;
49193   return jresult;
49194 }
49195
49196
49197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49198   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49199   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49200
49201   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49202   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49203   {
49204     try {
49205       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49206     } catch (std::out_of_range& e) {
49207       {
49208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49209       };
49210     } catch (std::exception& e) {
49211       {
49212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (...) {
49215       {
49216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49217       };
49218     }
49219   }
49220 }
49221
49222
49223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49224   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49225   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49226
49227   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49228   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49229   {
49230     try {
49231       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49239       };
49240     } catch (...) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49243       };
49244     }
49245   }
49246 }
49247
49248
49249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49250   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49251   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49252
49253   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49254   arg2 = (Dali::RefObject *)jarg2;
49255   {
49256     try {
49257       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49258     } catch (std::out_of_range& e) {
49259       {
49260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49261       };
49262     } catch (std::exception& e) {
49263       {
49264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49265       };
49266     } catch (...) {
49267       {
49268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49269       };
49270     }
49271   }
49272 }
49273
49274
49275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49276   void * jresult ;
49277   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49278
49279   {
49280     try {
49281       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49282     } catch (std::out_of_range& e) {
49283       {
49284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49285       };
49286     } catch (std::exception& e) {
49287       {
49288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49293       };
49294     }
49295   }
49296   jresult = (void *)result;
49297   return jresult;
49298 }
49299
49300
49301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49302   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49303
49304   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49305   {
49306     try {
49307       delete arg1;
49308     } catch (std::out_of_range& e) {
49309       {
49310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49311       };
49312     } catch (std::exception& e) {
49313       {
49314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49315       };
49316     } catch (...) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49319       };
49320     }
49321   }
49322 }
49323
49324
49325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49326   unsigned int jresult ;
49327   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49328   bool result;
49329
49330   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49331   {
49332     try {
49333       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49334     } catch (std::out_of_range& e) {
49335       {
49336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49337       };
49338     } catch (std::exception& e) {
49339       {
49340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49341       };
49342     } catch (...) {
49343       {
49344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49345       };
49346     }
49347   }
49348   jresult = result;
49349   return jresult;
49350 }
49351
49352
49353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49354   unsigned long jresult ;
49355   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49356   std::size_t result;
49357
49358   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49359   {
49360     try {
49361       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49362     } catch (std::out_of_range& e) {
49363       {
49364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49365       };
49366     } catch (std::exception& e) {
49367       {
49368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49369       };
49370     } catch (...) {
49371       {
49372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49373       };
49374     }
49375   }
49376   jresult = (unsigned long)result;
49377   return jresult;
49378 }
49379
49380
49381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49382   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49383   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49384
49385   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49386   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49387   {
49388     try {
49389       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49390     } catch (std::out_of_range& e) {
49391       {
49392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49393       };
49394     } catch (std::exception& e) {
49395       {
49396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49397       };
49398     } catch (...) {
49399       {
49400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49401       };
49402     }
49403   }
49404 }
49405
49406
49407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49408   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49409   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49410
49411   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49412   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49413   {
49414     try {
49415       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49416     } catch (std::out_of_range& e) {
49417       {
49418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49419       };
49420     } catch (std::exception& e) {
49421       {
49422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49423       };
49424     } catch (...) {
49425       {
49426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49427       };
49428     }
49429   }
49430 }
49431
49432
49433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49434   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49435   Dali::PropertyNotification *arg2 = 0 ;
49436
49437   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49438   arg2 = (Dali::PropertyNotification *)jarg2;
49439   if (!arg2) {
49440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49441     return ;
49442   }
49443   {
49444     try {
49445       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49446     } catch (std::out_of_range& e) {
49447       {
49448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49449       };
49450     } catch (std::exception& e) {
49451       {
49452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49453       };
49454     } catch (...) {
49455       {
49456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49457       };
49458     }
49459   }
49460 }
49461
49462
49463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49464   void * jresult ;
49465   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49466
49467   {
49468     try {
49469       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49470     } catch (std::out_of_range& e) {
49471       {
49472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49473       };
49474     } catch (std::exception& e) {
49475       {
49476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49477       };
49478     } catch (...) {
49479       {
49480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49481       };
49482     }
49483   }
49484   jresult = (void *)result;
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49490   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49491
49492   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49493   {
49494     try {
49495       delete arg1;
49496     } catch (std::out_of_range& e) {
49497       {
49498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49499       };
49500     } catch (std::exception& e) {
49501       {
49502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49507       };
49508     }
49509   }
49510 }
49511
49512
49513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49514   unsigned int jresult ;
49515   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49516   bool result;
49517
49518   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49519   {
49520     try {
49521       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49522     } catch (std::out_of_range& e) {
49523       {
49524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49525       };
49526     } catch (std::exception& e) {
49527       {
49528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49529       };
49530     } catch (...) {
49531       {
49532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49533       };
49534     }
49535   }
49536   jresult = result;
49537   return jresult;
49538 }
49539
49540
49541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49542   unsigned long jresult ;
49543   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49544   std::size_t result;
49545
49546   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49547   {
49548     try {
49549       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49550     } catch (std::out_of_range& e) {
49551       {
49552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49553       };
49554     } catch (std::exception& e) {
49555       {
49556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49557       };
49558     } catch (...) {
49559       {
49560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49561       };
49562     }
49563   }
49564   jresult = (unsigned long)result;
49565   return jresult;
49566 }
49567
49568
49569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49570   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49571   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49572
49573   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49574   arg2 = (void (*)(Dali::Image))jarg2;
49575   {
49576     try {
49577       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49578     } catch (std::out_of_range& e) {
49579       {
49580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (std::exception& e) {
49583       {
49584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49585       };
49586     } catch (...) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49589       };
49590     }
49591   }
49592 }
49593
49594
49595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49596   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49597   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49598
49599   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49600   arg2 = (void (*)(Dali::Image))jarg2;
49601   {
49602     try {
49603       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49604     } catch (std::out_of_range& e) {
49605       {
49606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49607       };
49608     } catch (std::exception& e) {
49609       {
49610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49611       };
49612     } catch (...) {
49613       {
49614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49615       };
49616     }
49617   }
49618 }
49619
49620
49621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49622   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49623   Dali::Image arg2 ;
49624   Dali::Image *argp2 ;
49625
49626   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49627   argp2 = (Dali::Image *)jarg2;
49628   if (!argp2) {
49629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49630     return ;
49631   }
49632   arg2 = *argp2;
49633   {
49634     try {
49635       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49636     } catch (std::out_of_range& e) {
49637       {
49638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49639       };
49640     } catch (std::exception& e) {
49641       {
49642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49643       };
49644     } catch (...) {
49645       {
49646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49647       };
49648     }
49649   }
49650 }
49651
49652
49653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49654   void * jresult ;
49655   Dali::Signal< void (Dali::Image) > *result = 0 ;
49656
49657   {
49658     try {
49659       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49660     } catch (std::out_of_range& e) {
49661       {
49662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49663       };
49664     } catch (std::exception& e) {
49665       {
49666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49667       };
49668     } catch (...) {
49669       {
49670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49671       };
49672     }
49673   }
49674   jresult = (void *)result;
49675   return jresult;
49676 }
49677
49678
49679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49680   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49681
49682   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49683   {
49684     try {
49685       delete arg1;
49686     } catch (std::out_of_range& e) {
49687       {
49688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49689       };
49690     } catch (std::exception& e) {
49691       {
49692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49693       };
49694     } catch (...) {
49695       {
49696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49697       };
49698     }
49699   }
49700 }
49701
49702
49703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49704   void * jresult ;
49705   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49706
49707   {
49708     try {
49709       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49717       };
49718     } catch (...) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49721       };
49722     }
49723   }
49724   jresult = (void *)result;
49725   return jresult;
49726 }
49727
49728
49729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49730   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49731
49732   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49733   {
49734     try {
49735       delete arg1;
49736     } catch (std::out_of_range& e) {
49737       {
49738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49739       };
49740     } catch (std::exception& e) {
49741       {
49742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49743       };
49744     } catch (...) {
49745       {
49746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49747       };
49748     }
49749   }
49750 }
49751
49752
49753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49754   unsigned int jresult ;
49755   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49756   bool result;
49757
49758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49759   {
49760     try {
49761       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);
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49769       };
49770     } catch (...) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49773       };
49774     }
49775   }
49776   jresult = result;
49777   return jresult;
49778 }
49779
49780
49781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49782   unsigned long jresult ;
49783   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49784   std::size_t result;
49785
49786   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49787   {
49788     try {
49789       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);
49790     } catch (std::out_of_range& e) {
49791       {
49792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49793       };
49794     } catch (std::exception& e) {
49795       {
49796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49797       };
49798     } catch (...) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49801       };
49802     }
49803   }
49804   jresult = (unsigned long)result;
49805   return jresult;
49806 }
49807
49808
49809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49810   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49811   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49812
49813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49814   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49815   {
49816     try {
49817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49818     } catch (std::out_of_range& e) {
49819       {
49820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (std::exception& e) {
49823       {
49824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49825       };
49826     } catch (...) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49829       };
49830     }
49831   }
49832 }
49833
49834
49835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49836   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49837   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49838
49839   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49840   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49841   {
49842     try {
49843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49855       };
49856     }
49857   }
49858 }
49859
49860
49861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49862   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49863   Dali::Actor arg2 ;
49864   Dali::LongPressGesture *arg3 = 0 ;
49865   Dali::Actor *argp2 ;
49866
49867   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49868   argp2 = (Dali::Actor *)jarg2;
49869   if (!argp2) {
49870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49871     return ;
49872   }
49873   arg2 = *argp2;
49874   arg3 = (Dali::LongPressGesture *)jarg3;
49875   if (!arg3) {
49876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49877     return ;
49878   }
49879   {
49880     try {
49881       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49882     } catch (std::out_of_range& e) {
49883       {
49884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49885       };
49886     } catch (std::exception& e) {
49887       {
49888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49889       };
49890     } catch (...) {
49891       {
49892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49893       };
49894     }
49895   }
49896 }
49897
49898
49899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49900   void * jresult ;
49901   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49902
49903   {
49904     try {
49905       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49906     } catch (std::out_of_range& e) {
49907       {
49908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49909       };
49910     } catch (std::exception& e) {
49911       {
49912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49913       };
49914     } catch (...) {
49915       {
49916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49917       };
49918     }
49919   }
49920   jresult = (void *)result;
49921   return jresult;
49922 }
49923
49924
49925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49926   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49927
49928   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49929   {
49930     try {
49931       delete arg1;
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49939       };
49940     } catch (...) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49943       };
49944     }
49945   }
49946 }
49947
49948
49949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49950   unsigned int jresult ;
49951   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49952   bool result;
49953
49954   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49955   {
49956     try {
49957       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);
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49969       };
49970     }
49971   }
49972   jresult = result;
49973   return jresult;
49974 }
49975
49976
49977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49978   unsigned long jresult ;
49979   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49980   std::size_t result;
49981
49982   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49983   {
49984     try {
49985       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);
49986     } catch (std::out_of_range& e) {
49987       {
49988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49989       };
49990     } catch (std::exception& e) {
49991       {
49992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49993       };
49994     } catch (...) {
49995       {
49996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49997       };
49998     }
49999   }
50000   jresult = (unsigned long)result;
50001   return jresult;
50002 }
50003
50004
50005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50006   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50007   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50008
50009   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50010   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50011   {
50012     try {
50013       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50014     } catch (std::out_of_range& e) {
50015       {
50016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50017       };
50018     } catch (std::exception& e) {
50019       {
50020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50021       };
50022     } catch (...) {
50023       {
50024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50025       };
50026     }
50027   }
50028 }
50029
50030
50031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50032   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50033   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50034
50035   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50036   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50037   {
50038     try {
50039       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50040     } catch (std::out_of_range& e) {
50041       {
50042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50043       };
50044     } catch (std::exception& e) {
50045       {
50046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50047       };
50048     } catch (...) {
50049       {
50050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50051       };
50052     }
50053   }
50054 }
50055
50056
50057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50058   unsigned int jresult ;
50059   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50060   Dali::Actor arg2 ;
50061   Dali::TouchData *arg3 = 0 ;
50062   Dali::Actor *argp2 ;
50063   bool result;
50064
50065   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50066   argp2 = (Dali::Actor *)jarg2;
50067   if (!argp2) {
50068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50069     return 0;
50070   }
50071   arg2 = *argp2;
50072   arg3 = (Dali::TouchData *)jarg3;
50073   if (!arg3) {
50074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50075     return 0;
50076   }
50077   {
50078     try {
50079       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50080     } catch (std::out_of_range& e) {
50081       {
50082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50083       };
50084     } catch (std::exception& e) {
50085       {
50086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50087       };
50088     } catch (...) {
50089       {
50090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50091       };
50092     }
50093   }
50094   jresult = result;
50095   return jresult;
50096 }
50097
50098
50099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50100   void * jresult ;
50101   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50102
50103   {
50104     try {
50105       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50106     } catch (std::out_of_range& e) {
50107       {
50108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50109       };
50110     } catch (std::exception& e) {
50111       {
50112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50113       };
50114     } catch (...) {
50115       {
50116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50117       };
50118     }
50119   }
50120   jresult = (void *)result;
50121   return jresult;
50122 }
50123
50124
50125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50126   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50127
50128   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50129   {
50130     try {
50131       delete arg1;
50132     } catch (std::out_of_range& e) {
50133       {
50134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50135       };
50136     } catch (std::exception& e) {
50137       {
50138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50139       };
50140     } catch (...) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50143       };
50144     }
50145   }
50146 }
50147
50148
50149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50150   unsigned int jresult ;
50151   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50152   bool result;
50153
50154   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50155   {
50156     try {
50157       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);
50158     } catch (std::out_of_range& e) {
50159       {
50160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50161       };
50162     } catch (std::exception& e) {
50163       {
50164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50165       };
50166     } catch (...) {
50167       {
50168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50169       };
50170     }
50171   }
50172   jresult = result;
50173   return jresult;
50174 }
50175
50176
50177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50178   unsigned long jresult ;
50179   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50180   std::size_t result;
50181
50182   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50183   {
50184     try {
50185       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);
50186     } catch (std::out_of_range& e) {
50187       {
50188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50189       };
50190     } catch (std::exception& e) {
50191       {
50192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50193       };
50194     } catch (...) {
50195       {
50196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50197       };
50198     }
50199   }
50200   jresult = (unsigned long)result;
50201   return jresult;
50202 }
50203
50204
50205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50206   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50207   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50208
50209   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50210   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50211   {
50212     try {
50213       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50214     } catch (std::out_of_range& e) {
50215       {
50216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50217       };
50218     } catch (std::exception& e) {
50219       {
50220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50221       };
50222     } catch (...) {
50223       {
50224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50225       };
50226     }
50227   }
50228 }
50229
50230
50231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50232   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50233   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50234
50235   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50236   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50237   {
50238     try {
50239       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50240     } catch (std::out_of_range& e) {
50241       {
50242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50243       };
50244     } catch (std::exception& e) {
50245       {
50246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50247       };
50248     } catch (...) {
50249       {
50250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50251       };
50252     }
50253   }
50254 }
50255
50256
50257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50258   unsigned int jresult ;
50259   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50260   Dali::Actor arg2 ;
50261   Dali::HoverEvent *arg3 = 0 ;
50262   Dali::Actor *argp2 ;
50263   bool result;
50264
50265   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50266   argp2 = (Dali::Actor *)jarg2;
50267   if (!argp2) {
50268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50269     return 0;
50270   }
50271   arg2 = *argp2;
50272   arg3 = (Dali::HoverEvent *)jarg3;
50273   if (!arg3) {
50274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50275     return 0;
50276   }
50277   {
50278     try {
50279       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50280     } catch (std::out_of_range& e) {
50281       {
50282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50283       };
50284     } catch (std::exception& e) {
50285       {
50286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50287       };
50288     } catch (...) {
50289       {
50290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50291       };
50292     }
50293   }
50294   jresult = result;
50295   return jresult;
50296 }
50297
50298
50299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50300   void * jresult ;
50301   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50302
50303   {
50304     try {
50305       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50306     } catch (std::out_of_range& e) {
50307       {
50308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50309       };
50310     } catch (std::exception& e) {
50311       {
50312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50313       };
50314     } catch (...) {
50315       {
50316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50317       };
50318     }
50319   }
50320   jresult = (void *)result;
50321   return jresult;
50322 }
50323
50324
50325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50326   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50327
50328   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50329   {
50330     try {
50331       delete arg1;
50332     } catch (std::out_of_range& e) {
50333       {
50334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50335       };
50336     } catch (std::exception& e) {
50337       {
50338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50339       };
50340     } catch (...) {
50341       {
50342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50343       };
50344     }
50345   }
50346 }
50347
50348
50349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50350   unsigned int jresult ;
50351   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50352   bool result;
50353
50354   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50355   {
50356     try {
50357       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);
50358     } catch (std::out_of_range& e) {
50359       {
50360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50361       };
50362     } catch (std::exception& e) {
50363       {
50364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50365       };
50366     } catch (...) {
50367       {
50368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50369       };
50370     }
50371   }
50372   jresult = result;
50373   return jresult;
50374 }
50375
50376
50377 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50378   unsigned long jresult ;
50379   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50380   std::size_t result;
50381
50382   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50383   {
50384     try {
50385       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);
50386     } catch (std::out_of_range& e) {
50387       {
50388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50389       };
50390     } catch (std::exception& e) {
50391       {
50392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50393       };
50394     } catch (...) {
50395       {
50396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50397       };
50398     }
50399   }
50400   jresult = (unsigned long)result;
50401   return jresult;
50402 }
50403
50404
50405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50406   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50407   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50408
50409   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50410   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50411   {
50412     try {
50413       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50414     } catch (std::out_of_range& e) {
50415       {
50416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50417       };
50418     } catch (std::exception& e) {
50419       {
50420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50421       };
50422     } catch (...) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50425       };
50426     }
50427   }
50428 }
50429
50430
50431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50432   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50433   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50434
50435   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50436   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50437   {
50438     try {
50439       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50440     } catch (std::out_of_range& e) {
50441       {
50442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50443       };
50444     } catch (std::exception& e) {
50445       {
50446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50447       };
50448     } catch (...) {
50449       {
50450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50451       };
50452     }
50453   }
50454 }
50455
50456
50457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50458   unsigned int jresult ;
50459   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50460   Dali::Actor arg2 ;
50461   Dali::WheelEvent *arg3 = 0 ;
50462   Dali::Actor *argp2 ;
50463   bool result;
50464
50465   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50466   argp2 = (Dali::Actor *)jarg2;
50467   if (!argp2) {
50468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50469     return 0;
50470   }
50471   arg2 = *argp2;
50472   arg3 = (Dali::WheelEvent *)jarg3;
50473   if (!arg3) {
50474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50475     return 0;
50476   }
50477   {
50478     try {
50479       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50480     } catch (std::out_of_range& e) {
50481       {
50482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50483       };
50484     } catch (std::exception& e) {
50485       {
50486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50487       };
50488     } catch (...) {
50489       {
50490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50491       };
50492     }
50493   }
50494   jresult = result;
50495   return jresult;
50496 }
50497
50498
50499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50500   void * jresult ;
50501   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50502
50503   {
50504     try {
50505       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50506     } catch (std::out_of_range& e) {
50507       {
50508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50509       };
50510     } catch (std::exception& e) {
50511       {
50512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50513       };
50514     } catch (...) {
50515       {
50516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50517       };
50518     }
50519   }
50520   jresult = (void *)result;
50521   return jresult;
50522 }
50523
50524
50525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50526   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50527
50528   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50529   {
50530     try {
50531       delete arg1;
50532     } catch (std::out_of_range& e) {
50533       {
50534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50535       };
50536     } catch (std::exception& e) {
50537       {
50538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50539       };
50540     } catch (...) {
50541       {
50542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50543       };
50544     }
50545   }
50546 }
50547
50548
50549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50550   unsigned int jresult ;
50551   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50552   bool result;
50553
50554   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50555   {
50556     try {
50557       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50558     } catch (std::out_of_range& e) {
50559       {
50560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50561       };
50562     } catch (std::exception& e) {
50563       {
50564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50565       };
50566     } catch (...) {
50567       {
50568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50569       };
50570     }
50571   }
50572   jresult = result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50578   unsigned long jresult ;
50579   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50580   std::size_t result;
50581
50582   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50583   {
50584     try {
50585       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50586     } catch (std::out_of_range& e) {
50587       {
50588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50589       };
50590     } catch (std::exception& e) {
50591       {
50592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50593       };
50594     } catch (...) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50597       };
50598     }
50599   }
50600   jresult = (unsigned long)result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50606   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50607   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50608
50609   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50610   arg2 = (void (*)(Dali::Actor))jarg2;
50611   {
50612     try {
50613       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50614     } catch (std::out_of_range& e) {
50615       {
50616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50617       };
50618     } catch (std::exception& e) {
50619       {
50620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50621       };
50622     } catch (...) {
50623       {
50624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50625       };
50626     }
50627   }
50628 }
50629
50630
50631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50632   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50633   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50634
50635   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50636   arg2 = (void (*)(Dali::Actor))jarg2;
50637   {
50638     try {
50639       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50640     } catch (std::out_of_range& e) {
50641       {
50642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50643       };
50644     } catch (std::exception& e) {
50645       {
50646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50647       };
50648     } catch (...) {
50649       {
50650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50651       };
50652     }
50653   }
50654 }
50655
50656
50657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50658   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50659   Dali::Actor arg2 ;
50660   Dali::Actor *argp2 ;
50661
50662   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50663   argp2 = (Dali::Actor *)jarg2;
50664   if (!argp2) {
50665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50666     return ;
50667   }
50668   arg2 = *argp2;
50669   {
50670     try {
50671       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50672     } catch (std::out_of_range& e) {
50673       {
50674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50675       };
50676     } catch (std::exception& e) {
50677       {
50678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50679       };
50680     } catch (...) {
50681       {
50682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50683       };
50684     }
50685   }
50686 }
50687
50688
50689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50690   void * jresult ;
50691   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50692
50693   {
50694     try {
50695       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50696     } catch (std::out_of_range& e) {
50697       {
50698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50699       };
50700     } catch (std::exception& e) {
50701       {
50702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50703       };
50704     } catch (...) {
50705       {
50706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50707       };
50708     }
50709   }
50710   jresult = (void *)result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50716   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50717
50718   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50719   {
50720     try {
50721       delete arg1;
50722     } catch (std::out_of_range& e) {
50723       {
50724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50725       };
50726     } catch (std::exception& e) {
50727       {
50728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50729       };
50730     } catch (...) {
50731       {
50732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50733       };
50734     }
50735   }
50736 }
50737
50738
50739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50740   unsigned int jresult ;
50741   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50742   bool result;
50743
50744   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50745   {
50746     try {
50747       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50748     } catch (std::out_of_range& e) {
50749       {
50750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50751       };
50752     } catch (std::exception& e) {
50753       {
50754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50755       };
50756     } catch (...) {
50757       {
50758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50759       };
50760     }
50761   }
50762   jresult = result;
50763   return jresult;
50764 }
50765
50766
50767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50768   unsigned long jresult ;
50769   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50770   std::size_t result;
50771
50772   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50773   {
50774     try {
50775       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50776     } catch (std::out_of_range& e) {
50777       {
50778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50779       };
50780     } catch (std::exception& e) {
50781       {
50782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50783       };
50784     } catch (...) {
50785       {
50786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50787       };
50788     }
50789   }
50790   jresult = (unsigned long)result;
50791   return jresult;
50792 }
50793
50794
50795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50796   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50797   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50798
50799   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50800   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50801   {
50802     try {
50803       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50804     } catch (std::out_of_range& e) {
50805       {
50806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50807       };
50808     } catch (std::exception& e) {
50809       {
50810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50811       };
50812     } catch (...) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50815       };
50816     }
50817   }
50818 }
50819
50820
50821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50822   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50823   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50824
50825   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50826   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50827   {
50828     try {
50829       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50830     } catch (std::out_of_range& e) {
50831       {
50832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50833       };
50834     } catch (std::exception& e) {
50835       {
50836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50837       };
50838     } catch (...) {
50839       {
50840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50841       };
50842     }
50843   }
50844 }
50845
50846
50847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50848   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50849   Dali::KeyEvent *arg2 = 0 ;
50850
50851   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50852   arg2 = (Dali::KeyEvent *)jarg2;
50853   if (!arg2) {
50854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50855     return ;
50856   }
50857   {
50858     try {
50859       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50860     } catch (std::out_of_range& e) {
50861       {
50862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50863       };
50864     } catch (std::exception& e) {
50865       {
50866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50867       };
50868     } catch (...) {
50869       {
50870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50871       };
50872     }
50873   }
50874 }
50875
50876
50877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50878   void * jresult ;
50879   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50880
50881   {
50882     try {
50883       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50884     } catch (std::out_of_range& e) {
50885       {
50886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50887       };
50888     } catch (std::exception& e) {
50889       {
50890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (...) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50895       };
50896     }
50897   }
50898   jresult = (void *)result;
50899   return jresult;
50900 }
50901
50902
50903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50904   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50905
50906   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50907   {
50908     try {
50909       delete arg1;
50910     } catch (std::out_of_range& e) {
50911       {
50912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50913       };
50914     } catch (std::exception& e) {
50915       {
50916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50917       };
50918     } catch (...) {
50919       {
50920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50921       };
50922     }
50923   }
50924 }
50925
50926
50927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50928   unsigned int jresult ;
50929   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50930   bool result;
50931
50932   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50933   {
50934     try {
50935       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50936     } catch (std::out_of_range& e) {
50937       {
50938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50939       };
50940     } catch (std::exception& e) {
50941       {
50942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50943       };
50944     } catch (...) {
50945       {
50946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50947       };
50948     }
50949   }
50950   jresult = result;
50951   return jresult;
50952 }
50953
50954
50955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50956   unsigned long jresult ;
50957   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50958   std::size_t result;
50959
50960   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50961   {
50962     try {
50963       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50964     } catch (std::out_of_range& e) {
50965       {
50966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50967       };
50968     } catch (std::exception& e) {
50969       {
50970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50971       };
50972     } catch (...) {
50973       {
50974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50975       };
50976     }
50977   }
50978   jresult = (unsigned long)result;
50979   return jresult;
50980 }
50981
50982
50983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50984   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50985   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50986
50987   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50988   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50989   {
50990     try {
50991       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50992     } catch (std::out_of_range& e) {
50993       {
50994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (std::exception& e) {
50997       {
50998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (...) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51003       };
51004     }
51005   }
51006 }
51007
51008
51009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51010   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51011   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51012
51013   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51014   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51015   {
51016     try {
51017       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51018     } catch (std::out_of_range& e) {
51019       {
51020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51021       };
51022     } catch (std::exception& e) {
51023       {
51024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51025       };
51026     } catch (...) {
51027       {
51028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51029       };
51030     }
51031   }
51032 }
51033
51034
51035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51036   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51037   Dali::TouchData *arg2 = 0 ;
51038
51039   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51040   arg2 = (Dali::TouchData *)jarg2;
51041   if (!arg2) {
51042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51043     return ;
51044   }
51045   {
51046     try {
51047       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51048     } catch (std::out_of_range& e) {
51049       {
51050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51051       };
51052     } catch (std::exception& e) {
51053       {
51054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51055       };
51056     } catch (...) {
51057       {
51058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51059       };
51060     }
51061   }
51062 }
51063
51064
51065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51066   void * jresult ;
51067   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51068
51069   {
51070     try {
51071       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51072     } catch (std::out_of_range& e) {
51073       {
51074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51075       };
51076     } catch (std::exception& e) {
51077       {
51078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51079       };
51080     } catch (...) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51083       };
51084     }
51085   }
51086   jresult = (void *)result;
51087   return jresult;
51088 }
51089
51090
51091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51092   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51093
51094   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51095   {
51096     try {
51097       delete arg1;
51098     } catch (std::out_of_range& e) {
51099       {
51100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51101       };
51102     } catch (std::exception& e) {
51103       {
51104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51105       };
51106     } catch (...) {
51107       {
51108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51109       };
51110     }
51111   }
51112 }
51113
51114
51115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51116   unsigned int jresult ;
51117   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51118   bool result;
51119
51120   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51121   {
51122     try {
51123       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51124     } catch (std::out_of_range& e) {
51125       {
51126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51127       };
51128     } catch (std::exception& e) {
51129       {
51130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51131       };
51132     } catch (...) {
51133       {
51134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51135       };
51136     }
51137   }
51138   jresult = result;
51139   return jresult;
51140 }
51141
51142
51143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51144   unsigned long jresult ;
51145   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51146   std::size_t result;
51147
51148   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51149   {
51150     try {
51151       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51152     } catch (std::out_of_range& e) {
51153       {
51154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51155       };
51156     } catch (std::exception& e) {
51157       {
51158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51159       };
51160     } catch (...) {
51161       {
51162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51163       };
51164     }
51165   }
51166   jresult = (unsigned long)result;
51167   return jresult;
51168 }
51169
51170
51171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51172   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51173   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51174
51175   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51176   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51177   {
51178     try {
51179       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51180     } catch (std::out_of_range& e) {
51181       {
51182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51183       };
51184     } catch (std::exception& e) {
51185       {
51186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51187       };
51188     } catch (...) {
51189       {
51190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51191       };
51192     }
51193   }
51194 }
51195
51196
51197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51198   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51199   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51200
51201   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51202   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51203   {
51204     try {
51205       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51206     } catch (std::out_of_range& e) {
51207       {
51208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51209       };
51210     } catch (std::exception& e) {
51211       {
51212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51213       };
51214     } catch (...) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51217       };
51218     }
51219   }
51220 }
51221
51222
51223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51224   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51225   Dali::WheelEvent *arg2 = 0 ;
51226
51227   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51228   arg2 = (Dali::WheelEvent *)jarg2;
51229   if (!arg2) {
51230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51231     return ;
51232   }
51233   {
51234     try {
51235       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51236     } catch (std::out_of_range& e) {
51237       {
51238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51239       };
51240     } catch (std::exception& e) {
51241       {
51242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51247       };
51248     }
51249   }
51250 }
51251
51252
51253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51254   void * jresult ;
51255   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51256
51257   {
51258     try {
51259       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51260     } catch (std::out_of_range& e) {
51261       {
51262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51263       };
51264     } catch (std::exception& e) {
51265       {
51266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51267       };
51268     } catch (...) {
51269       {
51270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51271       };
51272     }
51273   }
51274   jresult = (void *)result;
51275   return jresult;
51276 }
51277
51278
51279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51280   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51281
51282   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51283   {
51284     try {
51285       delete arg1;
51286     } catch (std::out_of_range& e) {
51287       {
51288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51289       };
51290     } catch (std::exception& e) {
51291       {
51292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51293       };
51294     } catch (...) {
51295       {
51296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51297       };
51298     }
51299   }
51300 }
51301
51302
51303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51304   void * jresult ;
51305   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51306
51307   {
51308     try {
51309       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51310     } catch (std::out_of_range& e) {
51311       {
51312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51313       };
51314     } catch (std::exception& e) {
51315       {
51316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51317       };
51318     } catch (...) {
51319       {
51320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51321       };
51322     }
51323   }
51324   jresult = (void *)result;
51325   return jresult;
51326 }
51327
51328
51329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51330   void * jresult ;
51331   Dali::Radian arg1 ;
51332   Dali::Radian arg2 ;
51333   Dali::Radian *argp1 ;
51334   Dali::Radian *argp2 ;
51335   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51336
51337   argp1 = (Dali::Radian *)jarg1;
51338   if (!argp1) {
51339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51340     return 0;
51341   }
51342   arg1 = *argp1;
51343   argp2 = (Dali::Radian *)jarg2;
51344   if (!argp2) {
51345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51346     return 0;
51347   }
51348   arg2 = *argp2;
51349   {
51350     try {
51351       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51352     } catch (std::out_of_range& e) {
51353       {
51354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51355       };
51356     } catch (std::exception& e) {
51357       {
51358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51363       };
51364     }
51365   }
51366   jresult = (void *)result;
51367   return jresult;
51368 }
51369
51370
51371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51372   void * jresult ;
51373   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51374   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51375
51376   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51377   if (!arg1) {
51378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51379     return 0;
51380   }
51381   {
51382     try {
51383       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51384     } catch (std::out_of_range& e) {
51385       {
51386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51387       };
51388     } catch (std::exception& e) {
51389       {
51390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51395       };
51396     }
51397   }
51398   jresult = (void *)result;
51399   return jresult;
51400 }
51401
51402
51403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51404   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51405   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51406
51407   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51408   arg2 = (Dali::Radian *)jarg2;
51409   if (arg1) (arg1)->first = *arg2;
51410 }
51411
51412
51413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51414   void * jresult ;
51415   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51416   Dali::Radian *result = 0 ;
51417
51418   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51419   result = (Dali::Radian *)& ((arg1)->first);
51420   jresult = (void *)result;
51421   return jresult;
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51426   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51427   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51428
51429   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51430   arg2 = (Dali::Radian *)jarg2;
51431   if (arg1) (arg1)->second = *arg2;
51432 }
51433
51434
51435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51436   void * jresult ;
51437   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51438   Dali::Radian *result = 0 ;
51439
51440   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51441   result = (Dali::Radian *)& ((arg1)->second);
51442   jresult = (void *)result;
51443   return jresult;
51444 }
51445
51446
51447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51448   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51449
51450   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51451   {
51452     try {
51453       delete arg1;
51454     } catch (std::out_of_range& e) {
51455       {
51456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51457       };
51458     } catch (std::exception& e) {
51459       {
51460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51461       };
51462     } catch (...) {
51463       {
51464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51465       };
51466     }
51467   }
51468 }
51469
51470
51471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51472   unsigned int jresult ;
51473   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51474   bool result;
51475
51476   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51477   {
51478     try {
51479       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);
51480     } catch (std::out_of_range& e) {
51481       {
51482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51483       };
51484     } catch (std::exception& e) {
51485       {
51486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51487       };
51488     } catch (...) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51491       };
51492     }
51493   }
51494   jresult = result;
51495   return jresult;
51496 }
51497
51498
51499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51500   unsigned long jresult ;
51501   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51502   std::size_t result;
51503
51504   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51505   {
51506     try {
51507       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);
51508     } catch (std::out_of_range& e) {
51509       {
51510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51511       };
51512     } catch (std::exception& e) {
51513       {
51514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51515       };
51516     } catch (...) {
51517       {
51518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51519       };
51520     }
51521   }
51522   jresult = (unsigned long)result;
51523   return jresult;
51524 }
51525
51526
51527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51528   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51529   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51530
51531   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51532   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51533   {
51534     try {
51535       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51536     } catch (std::out_of_range& e) {
51537       {
51538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51539       };
51540     } catch (std::exception& e) {
51541       {
51542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51543       };
51544     } catch (...) {
51545       {
51546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51547       };
51548     }
51549   }
51550 }
51551
51552
51553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51554   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51555   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51556
51557   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51558   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51559   {
51560     try {
51561       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51562     } catch (std::out_of_range& e) {
51563       {
51564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51565       };
51566     } catch (std::exception& e) {
51567       {
51568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51569       };
51570     } catch (...) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51573       };
51574     }
51575   }
51576 }
51577
51578
51579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51580   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51581   Dali::Actor arg2 ;
51582   Dali::PanGesture *arg3 = 0 ;
51583   Dali::Actor *argp2 ;
51584
51585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51586   argp2 = (Dali::Actor *)jarg2;
51587   if (!argp2) {
51588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51589     return ;
51590   }
51591   arg2 = *argp2;
51592   arg3 = (Dali::PanGesture *)jarg3;
51593   if (!arg3) {
51594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51595     return ;
51596   }
51597   {
51598     try {
51599       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51600     } catch (std::out_of_range& e) {
51601       {
51602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51603       };
51604     } catch (std::exception& e) {
51605       {
51606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51607       };
51608     } catch (...) {
51609       {
51610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51611       };
51612     }
51613   }
51614 }
51615
51616
51617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51618   void * jresult ;
51619   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51620
51621   {
51622     try {
51623       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51624     } catch (std::out_of_range& e) {
51625       {
51626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51627       };
51628     } catch (std::exception& e) {
51629       {
51630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51631       };
51632     } catch (...) {
51633       {
51634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51635       };
51636     }
51637   }
51638   jresult = (void *)result;
51639   return jresult;
51640 }
51641
51642
51643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51644   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51645
51646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51647   {
51648     try {
51649       delete arg1;
51650     } catch (std::out_of_range& e) {
51651       {
51652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51653       };
51654     } catch (std::exception& e) {
51655       {
51656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51657       };
51658     } catch (...) {
51659       {
51660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51661       };
51662     }
51663   }
51664 }
51665
51666
51667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51668   unsigned int jresult ;
51669   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51670   bool result;
51671
51672   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51673   {
51674     try {
51675       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);
51676     } catch (std::out_of_range& e) {
51677       {
51678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51679       };
51680     } catch (std::exception& e) {
51681       {
51682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51687       };
51688     }
51689   }
51690   jresult = result;
51691   return jresult;
51692 }
51693
51694
51695 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51696   unsigned long jresult ;
51697   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51698   std::size_t result;
51699
51700   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51701   {
51702     try {
51703       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);
51704     } catch (std::out_of_range& e) {
51705       {
51706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51707       };
51708     } catch (std::exception& e) {
51709       {
51710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51711       };
51712     } catch (...) {
51713       {
51714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51715       };
51716     }
51717   }
51718   jresult = (unsigned long)result;
51719   return jresult;
51720 }
51721
51722
51723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51724   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51725   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51726
51727   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51728   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51729   {
51730     try {
51731       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51732     } catch (std::out_of_range& e) {
51733       {
51734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51735       };
51736     } catch (std::exception& e) {
51737       {
51738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51739       };
51740     } catch (...) {
51741       {
51742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51743       };
51744     }
51745   }
51746 }
51747
51748
51749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51750   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51751   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51752
51753   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51754   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51755   {
51756     try {
51757       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51758     } catch (std::out_of_range& e) {
51759       {
51760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51761       };
51762     } catch (std::exception& e) {
51763       {
51764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51765       };
51766     } catch (...) {
51767       {
51768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51769       };
51770     }
51771   }
51772 }
51773
51774
51775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51776   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51777   Dali::Actor arg2 ;
51778   Dali::PinchGesture *arg3 = 0 ;
51779   Dali::Actor *argp2 ;
51780
51781   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51782   argp2 = (Dali::Actor *)jarg2;
51783   if (!argp2) {
51784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51785     return ;
51786   }
51787   arg2 = *argp2;
51788   arg3 = (Dali::PinchGesture *)jarg3;
51789   if (!arg3) {
51790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51791     return ;
51792   }
51793   {
51794     try {
51795       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51796     } catch (std::out_of_range& e) {
51797       {
51798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51799       };
51800     } catch (std::exception& e) {
51801       {
51802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51803       };
51804     } catch (...) {
51805       {
51806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51807       };
51808     }
51809   }
51810 }
51811
51812
51813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51814   void * jresult ;
51815   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51816
51817   {
51818     try {
51819       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834   jresult = (void *)result;
51835   return jresult;
51836 }
51837
51838
51839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51840   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51841
51842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51843   {
51844     try {
51845       delete arg1;
51846     } catch (std::out_of_range& e) {
51847       {
51848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51849       };
51850     } catch (std::exception& e) {
51851       {
51852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51853       };
51854     } catch (...) {
51855       {
51856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51857       };
51858     }
51859   }
51860 }
51861
51862
51863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51864   unsigned int jresult ;
51865   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51866   bool result;
51867
51868   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51869   {
51870     try {
51871       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);
51872     } catch (std::out_of_range& e) {
51873       {
51874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51875       };
51876     } catch (std::exception& e) {
51877       {
51878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51879       };
51880     } catch (...) {
51881       {
51882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51883       };
51884     }
51885   }
51886   jresult = result;
51887   return jresult;
51888 }
51889
51890
51891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51892   unsigned long jresult ;
51893   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51894   std::size_t result;
51895
51896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51897   {
51898     try {
51899       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);
51900     } catch (std::out_of_range& e) {
51901       {
51902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51903       };
51904     } catch (std::exception& e) {
51905       {
51906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51907       };
51908     } catch (...) {
51909       {
51910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51911       };
51912     }
51913   }
51914   jresult = (unsigned long)result;
51915   return jresult;
51916 }
51917
51918
51919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51920   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51921   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51922
51923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51924   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51925   {
51926     try {
51927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51928     } catch (std::out_of_range& e) {
51929       {
51930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51931       };
51932     } catch (std::exception& e) {
51933       {
51934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51935       };
51936     } catch (...) {
51937       {
51938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51939       };
51940     }
51941   }
51942 }
51943
51944
51945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51946   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51947   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51948
51949   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51950   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51951   {
51952     try {
51953       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51954     } catch (std::out_of_range& e) {
51955       {
51956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (std::exception& e) {
51959       {
51960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51961       };
51962     } catch (...) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51965       };
51966     }
51967   }
51968 }
51969
51970
51971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51972   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51973   Dali::Actor arg2 ;
51974   Dali::TapGesture *arg3 = 0 ;
51975   Dali::Actor *argp2 ;
51976
51977   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51978   argp2 = (Dali::Actor *)jarg2;
51979   if (!argp2) {
51980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51981     return ;
51982   }
51983   arg2 = *argp2;
51984   arg3 = (Dali::TapGesture *)jarg3;
51985   if (!arg3) {
51986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51987     return ;
51988   }
51989   {
51990     try {
51991       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51992     } catch (std::out_of_range& e) {
51993       {
51994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51995       };
51996     } catch (std::exception& e) {
51997       {
51998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51999       };
52000     } catch (...) {
52001       {
52002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52003       };
52004     }
52005   }
52006 }
52007
52008
52009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52010   void * jresult ;
52011   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52012
52013   {
52014     try {
52015       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52023       };
52024     } catch (...) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52027       };
52028     }
52029   }
52030   jresult = (void *)result;
52031   return jresult;
52032 }
52033
52034
52035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52036   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52037
52038   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52039   {
52040     try {
52041       delete arg1;
52042     } catch (std::out_of_range& e) {
52043       {
52044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52045       };
52046     } catch (std::exception& e) {
52047       {
52048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52049       };
52050     } catch (...) {
52051       {
52052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52053       };
52054     }
52055   }
52056 }
52057
52058
52059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52060   unsigned int jresult ;
52061   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52062   bool result;
52063
52064   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52065   {
52066     try {
52067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52068     } catch (std::out_of_range& e) {
52069       {
52070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52071       };
52072     } catch (std::exception& e) {
52073       {
52074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52075       };
52076     } catch (...) {
52077       {
52078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52079       };
52080     }
52081   }
52082   jresult = result;
52083   return jresult;
52084 }
52085
52086
52087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52088   unsigned long jresult ;
52089   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52090   std::size_t result;
52091
52092   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52093   {
52094     try {
52095       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52096     } catch (std::out_of_range& e) {
52097       {
52098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52099       };
52100     } catch (std::exception& e) {
52101       {
52102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52103       };
52104     } catch (...) {
52105       {
52106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52107       };
52108     }
52109   }
52110   jresult = (unsigned long)result;
52111   return jresult;
52112 }
52113
52114
52115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52116   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52117   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52118
52119   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52120   arg2 = (void (*)(Dali::Animation &))jarg2;
52121   {
52122     try {
52123       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52124     } catch (std::out_of_range& e) {
52125       {
52126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52127       };
52128     } catch (std::exception& e) {
52129       {
52130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52131       };
52132     } catch (...) {
52133       {
52134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52135       };
52136     }
52137   }
52138 }
52139
52140
52141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52142   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52143   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52144
52145   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52146   arg2 = (void (*)(Dali::Animation &))jarg2;
52147   {
52148     try {
52149       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52150     } catch (std::out_of_range& e) {
52151       {
52152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52153       };
52154     } catch (std::exception& e) {
52155       {
52156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52157       };
52158     } catch (...) {
52159       {
52160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52161       };
52162     }
52163   }
52164 }
52165
52166
52167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52168   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52169   Dali::Animation *arg2 = 0 ;
52170
52171   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52172   arg2 = (Dali::Animation *)jarg2;
52173   if (!arg2) {
52174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52175     return ;
52176   }
52177   {
52178     try {
52179       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52180     } catch (std::out_of_range& e) {
52181       {
52182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52183       };
52184     } catch (std::exception& e) {
52185       {
52186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (...) {
52189       {
52190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52191       };
52192     }
52193   }
52194 }
52195
52196
52197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52198   void * jresult ;
52199   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52200
52201   {
52202     try {
52203       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52204     } catch (std::out_of_range& e) {
52205       {
52206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52207       };
52208     } catch (std::exception& e) {
52209       {
52210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52211       };
52212     } catch (...) {
52213       {
52214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52215       };
52216     }
52217   }
52218   jresult = (void *)result;
52219   return jresult;
52220 }
52221
52222
52223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52224   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52225
52226   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52227   {
52228     try {
52229       delete arg1;
52230     } catch (std::out_of_range& e) {
52231       {
52232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52233       };
52234     } catch (std::exception& e) {
52235       {
52236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52237       };
52238     } catch (...) {
52239       {
52240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52241       };
52242     }
52243   }
52244 }
52245
52246
52247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52248   unsigned int jresult ;
52249   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52250   bool result;
52251
52252   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52253   {
52254     try {
52255       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52256     } catch (std::out_of_range& e) {
52257       {
52258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (std::exception& e) {
52261       {
52262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52267       };
52268     }
52269   }
52270   jresult = result;
52271   return jresult;
52272 }
52273
52274
52275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52276   unsigned long jresult ;
52277   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52278   std::size_t result;
52279
52280   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52281   {
52282     try {
52283       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52284     } catch (std::out_of_range& e) {
52285       {
52286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52287       };
52288     } catch (std::exception& e) {
52289       {
52290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52291       };
52292     } catch (...) {
52293       {
52294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52295       };
52296     }
52297   }
52298   jresult = (unsigned long)result;
52299   return jresult;
52300 }
52301
52302
52303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52304   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52305   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52306
52307   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52308   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52309   {
52310     try {
52311       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52312     } catch (std::out_of_range& e) {
52313       {
52314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52315       };
52316     } catch (std::exception& e) {
52317       {
52318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52319       };
52320     } catch (...) {
52321       {
52322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52323       };
52324     }
52325   }
52326 }
52327
52328
52329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52330   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52331   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52332
52333   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52334   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52335   {
52336     try {
52337       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52338     } catch (std::out_of_range& e) {
52339       {
52340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52341       };
52342     } catch (std::exception& e) {
52343       {
52344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52345       };
52346     } catch (...) {
52347       {
52348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52349       };
52350     }
52351   }
52352 }
52353
52354
52355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52356   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52357   Dali::ResourceImage arg2 ;
52358   Dali::ResourceImage *argp2 ;
52359
52360   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52361   argp2 = (Dali::ResourceImage *)jarg2;
52362   if (!argp2) {
52363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52364     return ;
52365   }
52366   arg2 = *argp2;
52367   {
52368     try {
52369       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52370     } catch (std::out_of_range& e) {
52371       {
52372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52373       };
52374     } catch (std::exception& e) {
52375       {
52376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52377       };
52378     } catch (...) {
52379       {
52380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52381       };
52382     }
52383   }
52384 }
52385
52386
52387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52388   void * jresult ;
52389   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52390
52391   {
52392     try {
52393       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52394     } catch (std::out_of_range& e) {
52395       {
52396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52397       };
52398     } catch (std::exception& e) {
52399       {
52400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52401       };
52402     } catch (...) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52405       };
52406     }
52407   }
52408   jresult = (void *)result;
52409   return jresult;
52410 }
52411
52412
52413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52414   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52415
52416   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52417   {
52418     try {
52419       delete arg1;
52420     } catch (std::out_of_range& e) {
52421       {
52422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52423       };
52424     } catch (std::exception& e) {
52425       {
52426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52427       };
52428     } catch (...) {
52429       {
52430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52431       };
52432     }
52433   }
52434 }
52435
52436
52437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52438   void * jresult ;
52439   Dali::Timer *result = 0 ;
52440
52441   {
52442     try {
52443       result = (Dali::Timer *)new Dali::Timer();
52444     } catch (std::out_of_range& e) {
52445       {
52446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52447       };
52448     } catch (std::exception& e) {
52449       {
52450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52451       };
52452     } catch (...) {
52453       {
52454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52455       };
52456     }
52457   }
52458   jresult = (void *)result;
52459   return jresult;
52460 }
52461
52462
52463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52464   void * jresult ;
52465   unsigned int arg1 ;
52466   Dali::Timer result;
52467
52468   arg1 = (unsigned int)jarg1;
52469   {
52470     try {
52471       result = Dali::Timer::New(arg1);
52472     } catch (std::out_of_range& e) {
52473       {
52474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52475       };
52476     } catch (std::exception& e) {
52477       {
52478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52479       };
52480     } catch (...) {
52481       {
52482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52483       };
52484     }
52485   }
52486   jresult = new Dali::Timer((const Dali::Timer &)result);
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52492   void * jresult ;
52493   Dali::Timer *arg1 = 0 ;
52494   Dali::Timer *result = 0 ;
52495
52496   arg1 = (Dali::Timer *)jarg1;
52497   if (!arg1) {
52498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52499     return 0;
52500   }
52501   {
52502     try {
52503       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52504     } catch (std::out_of_range& e) {
52505       {
52506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (std::exception& e) {
52509       {
52510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52511       };
52512     } catch (...) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52515       };
52516     }
52517   }
52518   jresult = (void *)result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52524   void * jresult ;
52525   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52526   Dali::Timer *arg2 = 0 ;
52527   Dali::Timer *result = 0 ;
52528
52529   arg1 = (Dali::Timer *)jarg1;
52530   arg2 = (Dali::Timer *)jarg2;
52531   if (!arg2) {
52532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52533     return 0;
52534   }
52535   {
52536     try {
52537       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52538     } catch (std::out_of_range& e) {
52539       {
52540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52541       };
52542     } catch (std::exception& e) {
52543       {
52544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52545       };
52546     } catch (...) {
52547       {
52548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52549       };
52550     }
52551   }
52552   jresult = (void *)result;
52553   return jresult;
52554 }
52555
52556
52557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52558   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52559
52560   arg1 = (Dali::Timer *)jarg1;
52561   {
52562     try {
52563       delete arg1;
52564     } catch (std::out_of_range& e) {
52565       {
52566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52567       };
52568     } catch (std::exception& e) {
52569       {
52570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52571       };
52572     } catch (...) {
52573       {
52574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52575       };
52576     }
52577   }
52578 }
52579
52580
52581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52582   void * jresult ;
52583   Dali::BaseHandle arg1 ;
52584   Dali::BaseHandle *argp1 ;
52585   Dali::Timer result;
52586
52587   argp1 = (Dali::BaseHandle *)jarg1;
52588   if (!argp1) {
52589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52590     return 0;
52591   }
52592   arg1 = *argp1;
52593   {
52594     try {
52595       result = Dali::Timer::DownCast(arg1);
52596     } catch (std::out_of_range& e) {
52597       {
52598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52599       };
52600     } catch (std::exception& e) {
52601       {
52602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52603       };
52604     } catch (...) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52607       };
52608     }
52609   }
52610   jresult = new Dali::Timer((const Dali::Timer &)result);
52611   return jresult;
52612 }
52613
52614
52615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52616   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52617
52618   arg1 = (Dali::Timer *)jarg1;
52619   {
52620     try {
52621       (arg1)->Start();
52622     } catch (std::out_of_range& e) {
52623       {
52624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52625       };
52626     } catch (std::exception& e) {
52627       {
52628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52629       };
52630     } catch (...) {
52631       {
52632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52633       };
52634     }
52635   }
52636 }
52637
52638
52639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52640   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52641
52642   arg1 = (Dali::Timer *)jarg1;
52643   {
52644     try {
52645       (arg1)->Stop();
52646     } catch (std::out_of_range& e) {
52647       {
52648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52649       };
52650     } catch (std::exception& e) {
52651       {
52652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52653       };
52654     } catch (...) {
52655       {
52656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52657       };
52658     }
52659   }
52660 }
52661
52662
52663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52664   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52665   unsigned int arg2 ;
52666
52667   arg1 = (Dali::Timer *)jarg1;
52668   arg2 = (unsigned int)jarg2;
52669   {
52670     try {
52671       (arg1)->SetInterval(arg2);
52672     } catch (std::out_of_range& e) {
52673       {
52674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52675       };
52676     } catch (std::exception& e) {
52677       {
52678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52679       };
52680     } catch (...) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52683       };
52684     }
52685   }
52686 }
52687
52688
52689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52690   unsigned int jresult ;
52691   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52692   unsigned int result;
52693
52694   arg1 = (Dali::Timer *)jarg1;
52695   {
52696     try {
52697       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52698     } catch (std::out_of_range& e) {
52699       {
52700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52701       };
52702     } catch (std::exception& e) {
52703       {
52704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52705       };
52706     } catch (...) {
52707       {
52708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52709       };
52710     }
52711   }
52712   jresult = result;
52713   return jresult;
52714 }
52715
52716
52717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52718   unsigned int jresult ;
52719   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52720   bool result;
52721
52722   arg1 = (Dali::Timer *)jarg1;
52723   {
52724     try {
52725       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52726     } catch (std::out_of_range& e) {
52727       {
52728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52729       };
52730     } catch (std::exception& e) {
52731       {
52732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52733       };
52734     } catch (...) {
52735       {
52736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52737       };
52738     }
52739   }
52740   jresult = result;
52741   return jresult;
52742 }
52743
52744
52745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52746   void * jresult ;
52747   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52748   Dali::Timer::TimerSignalType *result = 0 ;
52749
52750   arg1 = (Dali::Timer *)jarg1;
52751   {
52752     try {
52753       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52754     } catch (std::out_of_range& e) {
52755       {
52756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52757       };
52758     } catch (std::exception& e) {
52759       {
52760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52761       };
52762     } catch (...) {
52763       {
52764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52765       };
52766     }
52767   }
52768   jresult = (void *)result;
52769   return jresult;
52770 }
52771
52772
52773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52774   void * jresult ;
52775   Dali::DragAndDropDetector *result = 0 ;
52776
52777   {
52778     try {
52779       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52780     } catch (std::out_of_range& e) {
52781       {
52782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52783       };
52784     } catch (std::exception& e) {
52785       {
52786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52787       };
52788     } catch (...) {
52789       {
52790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52791       };
52792     }
52793   }
52794   jresult = (void *)result;
52795   return jresult;
52796 }
52797
52798
52799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52800   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52801
52802   arg1 = (Dali::DragAndDropDetector *)jarg1;
52803   {
52804     try {
52805       delete arg1;
52806     } catch (std::out_of_range& e) {
52807       {
52808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52809       };
52810     } catch (std::exception& e) {
52811       {
52812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52813       };
52814     } catch (...) {
52815       {
52816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52817       };
52818     }
52819   }
52820 }
52821
52822
52823 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52824   char * jresult ;
52825   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52826   std::string *result = 0 ;
52827
52828   arg1 = (Dali::DragAndDropDetector *)jarg1;
52829   {
52830     try {
52831       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52832     } catch (std::out_of_range& e) {
52833       {
52834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52835       };
52836     } catch (std::exception& e) {
52837       {
52838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52839       };
52840     } catch (...) {
52841       {
52842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52843       };
52844     }
52845   }
52846   jresult = SWIG_csharp_string_callback(result->c_str());
52847   return jresult;
52848 }
52849
52850
52851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52852   void * jresult ;
52853   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52854   Dali::Vector2 result;
52855
52856   arg1 = (Dali::DragAndDropDetector *)jarg1;
52857   {
52858     try {
52859       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52860     } catch (std::out_of_range& e) {
52861       {
52862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52863       };
52864     } catch (std::exception& e) {
52865       {
52866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52867       };
52868     } catch (...) {
52869       {
52870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52871       };
52872     }
52873   }
52874   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52875   return jresult;
52876 }
52877
52878
52879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52880   void * jresult ;
52881   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52882   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52883
52884   arg1 = (Dali::DragAndDropDetector *)jarg1;
52885   {
52886     try {
52887       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52888     } catch (std::out_of_range& e) {
52889       {
52890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52891       };
52892     } catch (std::exception& e) {
52893       {
52894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52899       };
52900     }
52901   }
52902   jresult = (void *)result;
52903   return jresult;
52904 }
52905
52906
52907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52908   void * jresult ;
52909   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52910   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52911
52912   arg1 = (Dali::DragAndDropDetector *)jarg1;
52913   {
52914     try {
52915       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52916     } catch (std::out_of_range& e) {
52917       {
52918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52919       };
52920     } catch (std::exception& e) {
52921       {
52922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52923       };
52924     } catch (...) {
52925       {
52926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52927       };
52928     }
52929   }
52930   jresult = (void *)result;
52931   return jresult;
52932 }
52933
52934
52935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52936   void * jresult ;
52937   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52938   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52939
52940   arg1 = (Dali::DragAndDropDetector *)jarg1;
52941   {
52942     try {
52943       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52944     } catch (std::out_of_range& e) {
52945       {
52946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52947       };
52948     } catch (std::exception& e) {
52949       {
52950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52951       };
52952     } catch (...) {
52953       {
52954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52955       };
52956     }
52957   }
52958   jresult = (void *)result;
52959   return jresult;
52960 }
52961
52962
52963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52964   void * jresult ;
52965   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52966   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52967
52968   arg1 = (Dali::DragAndDropDetector *)jarg1;
52969   {
52970     try {
52971       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52972     } catch (std::out_of_range& e) {
52973       {
52974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (std::exception& e) {
52977       {
52978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52979       };
52980     } catch (...) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52983       };
52984     }
52985   }
52986   jresult = (void *)result;
52987   return jresult;
52988 }
52989
52990
52991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52992   void * jresult ;
52993   Dali::ApplicationExtensions *result = 0 ;
52994
52995   {
52996     try {
52997       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53005       };
53006     } catch (...) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53009       };
53010     }
53011   }
53012   jresult = (void *)result;
53013   return jresult;
53014 }
53015
53016
53017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53018   void * jresult ;
53019   Dali::Application *arg1 = (Dali::Application *) 0 ;
53020   Dali::ApplicationExtensions *result = 0 ;
53021
53022   arg1 = (Dali::Application *)jarg1;
53023   {
53024     try {
53025       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53026     } catch (std::out_of_range& e) {
53027       {
53028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53029       };
53030     } catch (std::exception& e) {
53031       {
53032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53033       };
53034     } catch (...) {
53035       {
53036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53037       };
53038     }
53039   }
53040   jresult = (void *)result;
53041   return jresult;
53042 }
53043
53044
53045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53046   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53047
53048   arg1 = (Dali::ApplicationExtensions *)jarg1;
53049   {
53050     try {
53051       delete arg1;
53052     } catch (std::out_of_range& e) {
53053       {
53054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53055       };
53056     } catch (std::exception& e) {
53057       {
53058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53059       };
53060     } catch (...) {
53061       {
53062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53063       };
53064     }
53065   }
53066 }
53067
53068
53069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53070   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53071
53072   arg1 = (Dali::ApplicationExtensions *)jarg1;
53073   {
53074     try {
53075       (arg1)->Init();
53076     } catch (std::out_of_range& e) {
53077       {
53078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53079       };
53080     } catch (std::exception& e) {
53081       {
53082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53083       };
53084     } catch (...) {
53085       {
53086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53087       };
53088     }
53089   }
53090 }
53091
53092
53093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53094   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53095
53096   arg1 = (Dali::ApplicationExtensions *)jarg1;
53097   {
53098     try {
53099       (arg1)->Terminate();
53100     } catch (std::out_of_range& e) {
53101       {
53102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53103       };
53104     } catch (std::exception& e) {
53105       {
53106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53107       };
53108     } catch (...) {
53109       {
53110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53111       };
53112     }
53113   }
53114 }
53115
53116
53117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53118   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53119
53120   arg1 = (Dali::ApplicationExtensions *)jarg1;
53121   {
53122     try {
53123       (arg1)->Pause();
53124     } catch (std::out_of_range& e) {
53125       {
53126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53127       };
53128     } catch (std::exception& e) {
53129       {
53130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53135       };
53136     }
53137   }
53138 }
53139
53140
53141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53142   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53143
53144   arg1 = (Dali::ApplicationExtensions *)jarg1;
53145   {
53146     try {
53147       (arg1)->Resume();
53148     } catch (std::out_of_range& e) {
53149       {
53150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53151       };
53152     } catch (std::exception& e) {
53153       {
53154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53155       };
53156     } catch (...) {
53157       {
53158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53159       };
53160     }
53161   }
53162 }
53163
53164
53165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53166   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53167
53168   arg1 = (Dali::ApplicationExtensions *)jarg1;
53169   {
53170     try {
53171       (arg1)->LanguageChange();
53172     } catch (std::out_of_range& e) {
53173       {
53174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53175       };
53176     } catch (std::exception& e) {
53177       {
53178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53179       };
53180     } catch (...) {
53181       {
53182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53183       };
53184     }
53185   }
53186 }
53187
53188
53189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53190   void * jresult ;
53191   Dali::PositionSize arg1 ;
53192   std::string *arg2 = 0 ;
53193   bool arg3 ;
53194   Dali::PositionSize *argp1 ;
53195   Dali::Window result;
53196
53197   argp1 = (Dali::PositionSize *)jarg1;
53198   if (!argp1) {
53199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53200     return 0;
53201   }
53202   arg1 = *argp1;
53203   if (!jarg2) {
53204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53205     return 0;
53206   }
53207   std::string arg2_str(jarg2);
53208   arg2 = &arg2_str;
53209   arg3 = jarg3 ? true : false;
53210   {
53211     try {
53212       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53213     } catch (std::out_of_range& e) {
53214       {
53215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53216       };
53217     } catch (std::exception& e) {
53218       {
53219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53220       };
53221     } catch (...) {
53222       {
53223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53224       };
53225     }
53226   }
53227   jresult = new Dali::Window((const Dali::Window &)result);
53228
53229   //argout typemap for const std::string&
53230
53231   return jresult;
53232 }
53233
53234
53235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53236   void * jresult ;
53237   Dali::PositionSize arg1 ;
53238   std::string *arg2 = 0 ;
53239   Dali::PositionSize *argp1 ;
53240   Dali::Window result;
53241
53242   argp1 = (Dali::PositionSize *)jarg1;
53243   if (!argp1) {
53244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53245     return 0;
53246   }
53247   arg1 = *argp1;
53248   if (!jarg2) {
53249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53250     return 0;
53251   }
53252   std::string arg2_str(jarg2);
53253   arg2 = &arg2_str;
53254   {
53255     try {
53256       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53257     } catch (std::out_of_range& e) {
53258       {
53259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53260       };
53261     } catch (std::exception& e) {
53262       {
53263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53264       };
53265     } catch (...) {
53266       {
53267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53268       };
53269     }
53270   }
53271   jresult = new Dali::Window((const Dali::Window &)result);
53272
53273   //argout typemap for const std::string&
53274
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53280   void * jresult ;
53281   Dali::PositionSize arg1 ;
53282   std::string *arg2 = 0 ;
53283   std::string *arg3 = 0 ;
53284   bool arg4 ;
53285   Dali::PositionSize *argp1 ;
53286   Dali::Window result;
53287
53288   argp1 = (Dali::PositionSize *)jarg1;
53289   if (!argp1) {
53290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53291     return 0;
53292   }
53293   arg1 = *argp1;
53294   if (!jarg2) {
53295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53296     return 0;
53297   }
53298   std::string arg2_str(jarg2);
53299   arg2 = &arg2_str;
53300   if (!jarg3) {
53301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53302     return 0;
53303   }
53304   std::string arg3_str(jarg3);
53305   arg3 = &arg3_str;
53306   arg4 = jarg4 ? true : false;
53307   {
53308     try {
53309       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53310     } catch (std::out_of_range& e) {
53311       {
53312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53313       };
53314     } catch (std::exception& e) {
53315       {
53316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53317       };
53318     } catch (...) {
53319       {
53320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53321       };
53322     }
53323   }
53324   jresult = new Dali::Window((const Dali::Window &)result);
53325
53326   //argout typemap for const std::string&
53327
53328
53329   //argout typemap for const std::string&
53330
53331   return jresult;
53332 }
53333
53334
53335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53336   void * jresult ;
53337   Dali::PositionSize arg1 ;
53338   std::string *arg2 = 0 ;
53339   std::string *arg3 = 0 ;
53340   Dali::PositionSize *argp1 ;
53341   Dali::Window result;
53342
53343   argp1 = (Dali::PositionSize *)jarg1;
53344   if (!argp1) {
53345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53346     return 0;
53347   }
53348   arg1 = *argp1;
53349   if (!jarg2) {
53350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53351     return 0;
53352   }
53353   std::string arg2_str(jarg2);
53354   arg2 = &arg2_str;
53355   if (!jarg3) {
53356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53357     return 0;
53358   }
53359   std::string arg3_str(jarg3);
53360   arg3 = &arg3_str;
53361   {
53362     try {
53363       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53364     } catch (std::out_of_range& e) {
53365       {
53366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53367       };
53368     } catch (std::exception& e) {
53369       {
53370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53371       };
53372     } catch (...) {
53373       {
53374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53375       };
53376     }
53377   }
53378   jresult = new Dali::Window((const Dali::Window &)result);
53379
53380   //argout typemap for const std::string&
53381
53382
53383   //argout typemap for const std::string&
53384
53385   return jresult;
53386 }
53387
53388
53389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53390   void * jresult ;
53391   Dali::Window *result = 0 ;
53392
53393   {
53394     try {
53395       result = (Dali::Window *)new Dali::Window();
53396     } catch (std::out_of_range& e) {
53397       {
53398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53399       };
53400     } catch (std::exception& e) {
53401       {
53402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53403       };
53404     } catch (...) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53407       };
53408     }
53409   }
53410   jresult = (void *)result;
53411   return jresult;
53412 }
53413
53414
53415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53416   Dali::Window *arg1 = (Dali::Window *) 0 ;
53417
53418   arg1 = (Dali::Window *)jarg1;
53419   {
53420     try {
53421       delete arg1;
53422     } catch (std::out_of_range& e) {
53423       {
53424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53425       };
53426     } catch (std::exception& e) {
53427       {
53428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53429       };
53430     } catch (...) {
53431       {
53432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53433       };
53434     }
53435   }
53436 }
53437
53438
53439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53440   void * jresult ;
53441   Dali::Window *arg1 = 0 ;
53442   Dali::Window *result = 0 ;
53443
53444   arg1 = (Dali::Window *)jarg1;
53445   if (!arg1) {
53446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53447     return 0;
53448   }
53449   {
53450     try {
53451       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53452     } catch (std::out_of_range& e) {
53453       {
53454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53455       };
53456     } catch (std::exception& e) {
53457       {
53458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53459       };
53460     } catch (...) {
53461       {
53462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53463       };
53464     }
53465   }
53466   jresult = (void *)result;
53467   return jresult;
53468 }
53469
53470
53471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53472   void * jresult ;
53473   Dali::Window *arg1 = (Dali::Window *) 0 ;
53474   Dali::Window *arg2 = 0 ;
53475   Dali::Window *result = 0 ;
53476
53477   arg1 = (Dali::Window *)jarg1;
53478   arg2 = (Dali::Window *)jarg2;
53479   if (!arg2) {
53480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53481     return 0;
53482   }
53483   {
53484     try {
53485       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53486     } catch (std::out_of_range& e) {
53487       {
53488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53489       };
53490     } catch (std::exception& e) {
53491       {
53492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53493       };
53494     } catch (...) {
53495       {
53496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53497       };
53498     }
53499   }
53500   jresult = (void *)result;
53501   return jresult;
53502 }
53503
53504
53505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53506   Dali::Window *arg1 = (Dali::Window *) 0 ;
53507   Dali::Window::IndicatorVisibleMode arg2 ;
53508
53509   arg1 = (Dali::Window *)jarg1;
53510   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53511   {
53512     try {
53513       (arg1)->ShowIndicator(arg2);
53514     } catch (std::out_of_range& e) {
53515       {
53516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53517       };
53518     } catch (std::exception& e) {
53519       {
53520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (...) {
53523       {
53524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53525       };
53526     }
53527   }
53528 }
53529
53530
53531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53532   Dali::Window *arg1 = (Dali::Window *) 0 ;
53533   Dali::Window::IndicatorBgOpacity arg2 ;
53534
53535   arg1 = (Dali::Window *)jarg1;
53536   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53537   {
53538     try {
53539       (arg1)->SetIndicatorBgOpacity(arg2);
53540     } catch (std::out_of_range& e) {
53541       {
53542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53543       };
53544     } catch (std::exception& e) {
53545       {
53546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53547       };
53548     } catch (...) {
53549       {
53550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53551       };
53552     }
53553   }
53554 }
53555
53556
53557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53558   Dali::Window *arg1 = (Dali::Window *) 0 ;
53559   Dali::Window::WindowOrientation arg2 ;
53560
53561   arg1 = (Dali::Window *)jarg1;
53562   arg2 = (Dali::Window::WindowOrientation)jarg2;
53563   {
53564     try {
53565       (arg1)->RotateIndicator(arg2);
53566     } catch (std::out_of_range& e) {
53567       {
53568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53569       };
53570     } catch (std::exception& e) {
53571       {
53572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53573       };
53574     } catch (...) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53577       };
53578     }
53579   }
53580 }
53581
53582
53583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53584   Dali::Window *arg1 = (Dali::Window *) 0 ;
53585   std::string arg2 ;
53586   std::string arg3 ;
53587
53588   arg1 = (Dali::Window *)jarg1;
53589   if (!jarg2) {
53590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53591     return ;
53592   }
53593   (&arg2)->assign(jarg2);
53594   if (!jarg3) {
53595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53596     return ;
53597   }
53598   (&arg3)->assign(jarg3);
53599   {
53600     try {
53601       (arg1)->SetClass(arg2,arg3);
53602     } catch (std::out_of_range& e) {
53603       {
53604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (std::exception& e) {
53607       {
53608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53609       };
53610     } catch (...) {
53611       {
53612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53613       };
53614     }
53615   }
53616 }
53617
53618
53619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53620   Dali::Window *arg1 = (Dali::Window *) 0 ;
53621
53622   arg1 = (Dali::Window *)jarg1;
53623   {
53624     try {
53625       (arg1)->Raise();
53626     } catch (std::out_of_range& e) {
53627       {
53628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53629       };
53630     } catch (std::exception& e) {
53631       {
53632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53637       };
53638     }
53639   }
53640 }
53641
53642
53643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53644   Dali::Window *arg1 = (Dali::Window *) 0 ;
53645
53646   arg1 = (Dali::Window *)jarg1;
53647   {
53648     try {
53649       (arg1)->Lower();
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53661       };
53662     }
53663   }
53664 }
53665
53666
53667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53668   Dali::Window *arg1 = (Dali::Window *) 0 ;
53669
53670   arg1 = (Dali::Window *)jarg1;
53671   {
53672     try {
53673       (arg1)->Activate();
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53681       };
53682     } catch (...) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53685       };
53686     }
53687   }
53688 }
53689
53690
53691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53692   Dali::Window *arg1 = (Dali::Window *) 0 ;
53693   Dali::Window::WindowOrientation arg2 ;
53694
53695   arg1 = (Dali::Window *)jarg1;
53696   arg2 = (Dali::Window::WindowOrientation)jarg2;
53697   {
53698     try {
53699       (arg1)->AddAvailableOrientation(arg2);
53700     } catch (std::out_of_range& e) {
53701       {
53702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53703       };
53704     } catch (std::exception& e) {
53705       {
53706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53707       };
53708     } catch (...) {
53709       {
53710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53711       };
53712     }
53713   }
53714 }
53715
53716
53717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53718   Dali::Window *arg1 = (Dali::Window *) 0 ;
53719   Dali::Window::WindowOrientation arg2 ;
53720
53721   arg1 = (Dali::Window *)jarg1;
53722   arg2 = (Dali::Window::WindowOrientation)jarg2;
53723   {
53724     try {
53725       (arg1)->RemoveAvailableOrientation(arg2);
53726     } catch (std::out_of_range& e) {
53727       {
53728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53729       };
53730     } catch (std::exception& e) {
53731       {
53732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53733       };
53734     } catch (...) {
53735       {
53736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53737       };
53738     }
53739   }
53740 }
53741
53742
53743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53744   Dali::Window *arg1 = (Dali::Window *) 0 ;
53745   Dali::Window::WindowOrientation arg2 ;
53746
53747   arg1 = (Dali::Window *)jarg1;
53748   arg2 = (Dali::Window::WindowOrientation)jarg2;
53749   {
53750     try {
53751       (arg1)->SetPreferredOrientation(arg2);
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53763       };
53764     }
53765   }
53766 }
53767
53768
53769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53770   int jresult ;
53771   Dali::Window *arg1 = (Dali::Window *) 0 ;
53772   Dali::Window::WindowOrientation result;
53773
53774   arg1 = (Dali::Window *)jarg1;
53775   {
53776     try {
53777       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53778     } catch (std::out_of_range& e) {
53779       {
53780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53781       };
53782     } catch (std::exception& e) {
53783       {
53784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53785       };
53786     } catch (...) {
53787       {
53788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53789       };
53790     }
53791   }
53792   jresult = (int)result;
53793   return jresult;
53794 }
53795
53796
53797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53798   void * jresult ;
53799   Dali::Window *arg1 = (Dali::Window *) 0 ;
53800   Dali::DragAndDropDetector result;
53801
53802   arg1 = (Dali::Window *)jarg1;
53803   {
53804     try {
53805       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53806     } catch (std::out_of_range& e) {
53807       {
53808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53809       };
53810     } catch (std::exception& e) {
53811       {
53812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53813       };
53814     } catch (...) {
53815       {
53816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53817       };
53818     }
53819   }
53820   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53821   return jresult;
53822 }
53823
53824
53825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53826   void * jresult ;
53827   Dali::Window *arg1 = (Dali::Window *) 0 ;
53828   Dali::Any result;
53829
53830   arg1 = (Dali::Window *)jarg1;
53831   {
53832     try {
53833       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53834     } catch (std::out_of_range& e) {
53835       {
53836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53837       };
53838     } catch (std::exception& e) {
53839       {
53840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53841       };
53842     } catch (...) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53845       };
53846     }
53847   }
53848   jresult = new Dali::Any((const Dali::Any &)result);
53849   return jresult;
53850 }
53851
53852
53853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
53854   void * jresult ;
53855   Dali::Window arg1 ;
53856   Dali::Window *argp1 ;
53857   Dali::DevelWindow::FocusSignalType *result = 0 ;
53858
53859   argp1 = (Dali::Window *)jarg1;
53860   if (!argp1) {
53861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53862     return 0;
53863   }
53864   arg1 = *argp1;
53865   {
53866     try {
53867       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
53868     } catch (std::out_of_range& e) {
53869       {
53870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53871       };
53872     } catch (std::exception& e) {
53873       {
53874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53875       };
53876     } catch (...) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53879       };
53880     }
53881   }
53882   jresult = (void *)result;
53883   return jresult;
53884 }
53885
53886
53887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
53888   Dali::Window arg1 ;
53889   bool arg2 ;
53890   Dali::Window *argp1 ;
53891
53892   argp1 = (Dali::Window *)jarg1;
53893   if (!argp1) {
53894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53895     return ;
53896   }
53897   arg1 = *argp1;
53898   arg2 = jarg2 ? true : false;
53899   {
53900     try {
53901       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
53902     } catch (std::out_of_range& e) {
53903       {
53904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53905       };
53906     } catch (std::exception& e) {
53907       {
53908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53909       };
53910     } catch (...) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53913       };
53914     }
53915   }
53916 }
53917
53918
53919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
53920   unsigned int jresult ;
53921   Dali::Window arg1 ;
53922   Dali::Window *argp1 ;
53923   bool result;
53924
53925   argp1 = (Dali::Window *)jarg1;
53926   if (!argp1) {
53927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53928     return 0;
53929   }
53930   arg1 = *argp1;
53931   {
53932     try {
53933       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
53934     } catch (std::out_of_range& e) {
53935       {
53936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53937       };
53938     } catch (std::exception& e) {
53939       {
53940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53945       };
53946     }
53947   }
53948   jresult = result;
53949   return jresult;
53950 }
53951
53952
53953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
53954   Dali::Window arg1 ;
53955   Dali::Window *argp1 ;
53956
53957   argp1 = (Dali::Window *)jarg1;
53958   if (!argp1) {
53959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53960     return ;
53961   }
53962   arg1 = *argp1;
53963   {
53964     try {
53965       Dali::DevelWindow::Show(arg1);
53966     } catch (std::out_of_range& e) {
53967       {
53968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (std::exception& e) {
53971       {
53972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53977       };
53978     }
53979   }
53980 }
53981
53982
53983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
53984   Dali::Window arg1 ;
53985   Dali::Window *argp1 ;
53986
53987   argp1 = (Dali::Window *)jarg1;
53988   if (!argp1) {
53989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53990     return ;
53991   }
53992   arg1 = *argp1;
53993   {
53994     try {
53995       Dali::DevelWindow::Hide(arg1);
53996     } catch (std::out_of_range& e) {
53997       {
53998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53999       };
54000     } catch (std::exception& e) {
54001       {
54002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54003       };
54004     } catch (...) {
54005       {
54006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54007       };
54008     }
54009   }
54010 }
54011
54012
54013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54014   unsigned int jresult ;
54015   Dali::Window arg1 ;
54016   Dali::Window *argp1 ;
54017   bool result;
54018
54019   argp1 = (Dali::Window *)jarg1;
54020   if (!argp1) {
54021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54022     return 0;
54023   }
54024   arg1 = *argp1;
54025   {
54026     try {
54027       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54028     } catch (std::out_of_range& e) {
54029       {
54030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54031       };
54032     } catch (std::exception& e) {
54033       {
54034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54035       };
54036     } catch (...) {
54037       {
54038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54039       };
54040     }
54041   }
54042   jresult = result;
54043   return jresult;
54044 }
54045
54046
54047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54048   void * jresult ;
54049   Dali::Application result;
54050
54051   {
54052     try {
54053       result = Dali::Application::New();
54054     } catch (std::out_of_range& e) {
54055       {
54056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54057       };
54058     } catch (std::exception& e) {
54059       {
54060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54061       };
54062     } catch (...) {
54063       {
54064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54065       };
54066     }
54067   }
54068   jresult = new Dali::Application((const Dali::Application &)result);
54069   return jresult;
54070 }
54071
54072
54073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54074   void * jresult ;
54075   int *arg1 = (int *) 0 ;
54076   char ***arg2 ;
54077   Dali::Application result;
54078
54079   {
54080     // Todo generate argv data from the C# args
54081     char **array;         // two dimensional array
54082     int numStrings = 1;     // number of strings
54083     int stringLength = 30;      // max string length.
54084     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54085     argV = array;
54086
54087     // allocate the string data
54088     for( int i=0; i < numStrings; i++)
54089     {
54090       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54091     }
54092     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54093
54094     strcpy( array[0], "dali-csharp-app");
54095
54096     arg1 = &argC;
54097     arg2 = &argV;
54098   }
54099   {
54100     try {
54101       result = Dali::Application::New(arg1,arg2);
54102     } catch (std::out_of_range& e) {
54103       {
54104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54105       };
54106     } catch (std::exception& e) {
54107       {
54108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54109       };
54110     } catch (...) {
54111       {
54112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54113       };
54114     }
54115   }
54116   jresult = new Dali::Application((const Dali::Application &)result);
54117   return jresult;
54118 }
54119
54120
54121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54122   void * jresult ;
54123   int *arg1 = (int *) 0 ;
54124   char ***arg2 ;
54125   std::string *arg3 = 0 ;
54126   Dali::Application result;
54127
54128   {
54129     // Todo generate argv data from the C# args
54130     char **array;         // two dimensional array
54131     int numStrings = 1;     // number of strings
54132     int stringLength = 30;      // max string length.
54133     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54134     argV = array;
54135
54136     // allocate the string data
54137     for( int i=0; i < numStrings; i++)
54138     {
54139       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54140     }
54141     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54142
54143     strcpy( array[0], "dali-csharp-app");
54144
54145     arg1 = &argC;
54146     arg2 = &argV;
54147   }
54148   if (!jarg3) {
54149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54150     return 0;
54151   }
54152   std::string arg3_str(jarg3);
54153   arg3 = &arg3_str;
54154   {
54155     try {
54156       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54157     } catch (std::out_of_range& e) {
54158       {
54159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54160       };
54161     } catch (std::exception& e) {
54162       {
54163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54164       };
54165     } catch (...) {
54166       {
54167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54168       };
54169     }
54170   }
54171   jresult = new Dali::Application((const Dali::Application &)result);
54172
54173   //argout typemap for const std::string&
54174
54175   return jresult;
54176 }
54177
54178
54179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54180   void * jresult ;
54181   int *arg1 = (int *) 0 ;
54182   char ***arg2 ;
54183   std::string *arg3 = 0 ;
54184   Dali::Application::WINDOW_MODE arg4 ;
54185   Dali::Application result;
54186
54187   {
54188     // Todo generate argv data from the C# args
54189     char **array;         // two dimensional array
54190     int numStrings = 1;     // number of strings
54191     int stringLength = 30;      // max string length.
54192     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54193     argV = array;
54194
54195     // allocate the string data
54196     for( int i=0; i < numStrings; i++)
54197     {
54198       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54199     }
54200     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54201
54202     strcpy( array[0], "dali-csharp-app");
54203
54204     arg1 = &argC;
54205     arg2 = &argV;
54206   }
54207   if (!jarg3) {
54208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54209     return 0;
54210   }
54211   std::string arg3_str(jarg3);
54212   arg3 = &arg3_str;
54213   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54214   {
54215     try {
54216       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54217     } catch (std::out_of_range& e) {
54218       {
54219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54220       };
54221     } catch (std::exception& e) {
54222       {
54223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54228       };
54229     }
54230   }
54231   jresult = new Dali::Application((const Dali::Application &)result);
54232
54233   //argout typemap for const std::string&
54234
54235   return jresult;
54236 }
54237
54238
54239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54240   void * jresult ;
54241   Dali::Application *result = 0 ;
54242
54243   {
54244     try {
54245       result = (Dali::Application *)new Dali::Application();
54246     } catch (std::out_of_range& e) {
54247       {
54248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54249       };
54250     } catch (std::exception& e) {
54251       {
54252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54253       };
54254     } catch (...) {
54255       {
54256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54257       };
54258     }
54259   }
54260   jresult = (void *)result;
54261   return jresult;
54262 }
54263
54264
54265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54266   void * jresult ;
54267   Dali::Application *arg1 = 0 ;
54268   Dali::Application *result = 0 ;
54269
54270   arg1 = (Dali::Application *)jarg1;
54271   if (!arg1) {
54272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54273     return 0;
54274   }
54275   {
54276     try {
54277       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54285       };
54286     } catch (...) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54289       };
54290     }
54291   }
54292   jresult = (void *)result;
54293   return jresult;
54294 }
54295
54296
54297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54298   void * jresult ;
54299   Dali::Application *arg1 = (Dali::Application *) 0 ;
54300   Dali::Application *arg2 = 0 ;
54301   Dali::Application *result = 0 ;
54302
54303   arg1 = (Dali::Application *)jarg1;
54304   arg2 = (Dali::Application *)jarg2;
54305   if (!arg2) {
54306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54307     return 0;
54308   }
54309   {
54310     try {
54311       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54312     } catch (std::out_of_range& e) {
54313       {
54314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54315       };
54316     } catch (std::exception& e) {
54317       {
54318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54319       };
54320     } catch (...) {
54321       {
54322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54323       };
54324     }
54325   }
54326   jresult = (void *)result;
54327   return jresult;
54328 }
54329
54330
54331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54332   Dali::Application *arg1 = (Dali::Application *) 0 ;
54333
54334   arg1 = (Dali::Application *)jarg1;
54335   {
54336     try {
54337       delete arg1;
54338     } catch (std::out_of_range& e) {
54339       {
54340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54341       };
54342     } catch (std::exception& e) {
54343       {
54344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54345       };
54346     } catch (...) {
54347       {
54348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54349       };
54350     }
54351   }
54352 }
54353
54354
54355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54356   Dali::Application *arg1 = (Dali::Application *) 0 ;
54357
54358   arg1 = (Dali::Application *)jarg1;
54359   {
54360     try {
54361       (arg1)->MainLoop();
54362     } catch (std::out_of_range& e) {
54363       {
54364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54365       };
54366     } catch (std::exception& e) {
54367       {
54368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54369       };
54370     } catch (...) {
54371       {
54372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54373       };
54374     }
54375   }
54376 }
54377
54378
54379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54380   Dali::Application *arg1 = (Dali::Application *) 0 ;
54381   Configuration::ContextLoss arg2 ;
54382   Configuration::ContextLoss *argp2 ;
54383
54384   arg1 = (Dali::Application *)jarg1;
54385   argp2 = (Configuration::ContextLoss *)jarg2;
54386   if (!argp2) {
54387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54388     return ;
54389   }
54390   arg2 = *argp2;
54391   {
54392     try {
54393       (arg1)->MainLoop(arg2);
54394     } catch (std::out_of_range& e) {
54395       {
54396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54397       };
54398     } catch (std::exception& e) {
54399       {
54400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54401       };
54402     } catch (...) {
54403       {
54404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54405       };
54406     }
54407   }
54408 }
54409
54410
54411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54412   Dali::Application *arg1 = (Dali::Application *) 0 ;
54413
54414   arg1 = (Dali::Application *)jarg1;
54415   {
54416     try {
54417       (arg1)->Lower();
54418     } catch (std::out_of_range& e) {
54419       {
54420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54421       };
54422     } catch (std::exception& e) {
54423       {
54424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54425       };
54426     } catch (...) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54429       };
54430     }
54431   }
54432 }
54433
54434
54435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54436   Dali::Application *arg1 = (Dali::Application *) 0 ;
54437
54438   arg1 = (Dali::Application *)jarg1;
54439   {
54440     try {
54441       (arg1)->Quit();
54442     } catch (std::out_of_range& e) {
54443       {
54444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54445       };
54446     } catch (std::exception& e) {
54447       {
54448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54449       };
54450     } catch (...) {
54451       {
54452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54453       };
54454     }
54455   }
54456 }
54457
54458
54459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54460   unsigned int jresult ;
54461   Dali::Application *arg1 = (Dali::Application *) 0 ;
54462   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54463   bool result;
54464
54465   arg1 = (Dali::Application *)jarg1;
54466   arg2 = (Dali::CallbackBase *)jarg2;
54467   {
54468     try {
54469       result = (bool)(arg1)->AddIdle(arg2);
54470     } catch (std::out_of_range& e) {
54471       {
54472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54473       };
54474     } catch (std::exception& e) {
54475       {
54476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (...) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54481       };
54482     }
54483   }
54484   jresult = result;
54485   return jresult;
54486 }
54487
54488
54489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54490   void * jresult ;
54491   Dali::Application *arg1 = (Dali::Application *) 0 ;
54492   Dali::Window result;
54493
54494   arg1 = (Dali::Application *)jarg1;
54495   {
54496     try {
54497       result = (arg1)->GetWindow();
54498     } catch (std::out_of_range& e) {
54499       {
54500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54501       };
54502     } catch (std::exception& e) {
54503       {
54504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54505       };
54506     } catch (...) {
54507       {
54508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54509       };
54510     }
54511   }
54512   jresult = new Dali::Window((const Dali::Window &)result);
54513   return jresult;
54514 }
54515
54516
54517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54518   Dali::Application *arg1 = (Dali::Application *) 0 ;
54519   Dali::PositionSize arg2 ;
54520   std::string *arg3 = 0 ;
54521   Dali::PositionSize *argp2 ;
54522
54523   arg1 = (Dali::Application *)jarg1;
54524   argp2 = (Dali::PositionSize *)jarg2;
54525   if (!argp2) {
54526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54527     return ;
54528   }
54529   arg2 = *argp2;
54530   if (!jarg3) {
54531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54532     return ;
54533   }
54534   std::string arg3_str(jarg3);
54535   arg3 = &arg3_str;
54536   {
54537     try {
54538       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54539     } catch (std::out_of_range& e) {
54540       {
54541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54542       };
54543     } catch (std::exception& e) {
54544       {
54545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54550       };
54551     }
54552   }
54553
54554   //argout typemap for const std::string&
54555
54556 }
54557
54558
54559 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54560   char * jresult ;
54561   std::string result;
54562
54563   {
54564     try {
54565       result = Dali::Application::GetResourcePath();
54566     } catch (std::out_of_range& e) {
54567       {
54568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (std::exception& e) {
54571       {
54572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54577       };
54578     }
54579   }
54580   jresult = SWIG_csharp_string_callback((&result)->c_str());
54581   return jresult;
54582 }
54583
54584
54585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54586   Dali::Application *arg1 = (Dali::Application *) 0 ;
54587   Dali::ViewMode arg2 ;
54588
54589   arg1 = (Dali::Application *)jarg1;
54590   arg2 = (Dali::ViewMode)jarg2;
54591   {
54592     try {
54593       (arg1)->SetViewMode(arg2);
54594     } catch (std::out_of_range& e) {
54595       {
54596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54597       };
54598     } catch (std::exception& e) {
54599       {
54600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (...) {
54603       {
54604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54605       };
54606     }
54607   }
54608 }
54609
54610
54611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54612   int jresult ;
54613   Dali::Application *arg1 = (Dali::Application *) 0 ;
54614   Dali::ViewMode result;
54615
54616   arg1 = (Dali::Application *)jarg1;
54617   {
54618     try {
54619       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54620     } catch (std::out_of_range& e) {
54621       {
54622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54623       };
54624     } catch (std::exception& e) {
54625       {
54626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (...) {
54629       {
54630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54631       };
54632     }
54633   }
54634   jresult = (int)result;
54635   return jresult;
54636 }
54637
54638
54639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54640   Dali::Application *arg1 = (Dali::Application *) 0 ;
54641   float arg2 ;
54642
54643   arg1 = (Dali::Application *)jarg1;
54644   arg2 = (float)jarg2;
54645   {
54646     try {
54647       (arg1)->SetStereoBase(arg2);
54648     } catch (std::out_of_range& e) {
54649       {
54650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54651       };
54652     } catch (std::exception& e) {
54653       {
54654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54655       };
54656     } catch (...) {
54657       {
54658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54659       };
54660     }
54661   }
54662 }
54663
54664
54665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54666   float jresult ;
54667   Dali::Application *arg1 = (Dali::Application *) 0 ;
54668   float result;
54669
54670   arg1 = (Dali::Application *)jarg1;
54671   {
54672     try {
54673       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54674     } catch (std::out_of_range& e) {
54675       {
54676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54677       };
54678     } catch (std::exception& e) {
54679       {
54680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54681       };
54682     } catch (...) {
54683       {
54684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54685       };
54686     }
54687   }
54688   jresult = result;
54689   return jresult;
54690 }
54691
54692
54693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54694   void * jresult ;
54695   Dali::Application *arg1 = (Dali::Application *) 0 ;
54696   Dali::Application::AppSignalType *result = 0 ;
54697
54698   arg1 = (Dali::Application *)jarg1;
54699   {
54700     try {
54701       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54702     } catch (std::out_of_range& e) {
54703       {
54704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54705       };
54706     } catch (std::exception& e) {
54707       {
54708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54709       };
54710     } catch (...) {
54711       {
54712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54713       };
54714     }
54715   }
54716   jresult = (void *)result;
54717   return jresult;
54718 }
54719
54720
54721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54722   void * jresult ;
54723   Dali::Application *arg1 = (Dali::Application *) 0 ;
54724   Dali::Application::AppSignalType *result = 0 ;
54725
54726   arg1 = (Dali::Application *)jarg1;
54727   {
54728     try {
54729       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54730     } catch (std::out_of_range& e) {
54731       {
54732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (std::exception& e) {
54735       {
54736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54737       };
54738     } catch (...) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54741       };
54742     }
54743   }
54744   jresult = (void *)result;
54745   return jresult;
54746 }
54747
54748
54749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54750   void * jresult ;
54751   Dali::Application *arg1 = (Dali::Application *) 0 ;
54752   Dali::Application::AppSignalType *result = 0 ;
54753
54754   arg1 = (Dali::Application *)jarg1;
54755   {
54756     try {
54757       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54765       };
54766     } catch (...) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54769       };
54770     }
54771   }
54772   jresult = (void *)result;
54773   return jresult;
54774 }
54775
54776
54777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54778   void * jresult ;
54779   Dali::Application *arg1 = (Dali::Application *) 0 ;
54780   Dali::Application::AppSignalType *result = 0 ;
54781
54782   arg1 = (Dali::Application *)jarg1;
54783   {
54784     try {
54785       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54786     } catch (std::out_of_range& e) {
54787       {
54788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54789       };
54790     } catch (std::exception& e) {
54791       {
54792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54793       };
54794     } catch (...) {
54795       {
54796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54797       };
54798     }
54799   }
54800   jresult = (void *)result;
54801   return jresult;
54802 }
54803
54804
54805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54806   void * jresult ;
54807   Dali::Application *arg1 = (Dali::Application *) 0 ;
54808   Dali::Application::AppSignalType *result = 0 ;
54809
54810   arg1 = (Dali::Application *)jarg1;
54811   {
54812     try {
54813       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54814     } catch (std::out_of_range& e) {
54815       {
54816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54817       };
54818     } catch (std::exception& e) {
54819       {
54820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54821       };
54822     } catch (...) {
54823       {
54824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54825       };
54826     }
54827   }
54828   jresult = (void *)result;
54829   return jresult;
54830 }
54831
54832
54833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54834   void * jresult ;
54835   Dali::Application *arg1 = (Dali::Application *) 0 ;
54836   Dali::Application::AppSignalType *result = 0 ;
54837
54838   arg1 = (Dali::Application *)jarg1;
54839   {
54840     try {
54841       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54842     } catch (std::out_of_range& e) {
54843       {
54844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54845       };
54846     } catch (std::exception& e) {
54847       {
54848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54849       };
54850     } catch (...) {
54851       {
54852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54853       };
54854     }
54855   }
54856   jresult = (void *)result;
54857   return jresult;
54858 }
54859
54860
54861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54862   void * jresult ;
54863   Dali::Application *arg1 = (Dali::Application *) 0 ;
54864   Dali::Application::AppControlSignalType *result = 0 ;
54865
54866   arg1 = (Dali::Application *)jarg1;
54867   {
54868     try {
54869       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54870     } catch (std::out_of_range& e) {
54871       {
54872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54873       };
54874     } catch (std::exception& e) {
54875       {
54876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (...) {
54879       {
54880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54881       };
54882     }
54883   }
54884   jresult = (void *)result;
54885   return jresult;
54886 }
54887
54888
54889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54890   void * jresult ;
54891   Dali::Application *arg1 = (Dali::Application *) 0 ;
54892   Dali::Application::AppSignalType *result = 0 ;
54893
54894   arg1 = (Dali::Application *)jarg1;
54895   {
54896     try {
54897       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54898     } catch (std::out_of_range& e) {
54899       {
54900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54901       };
54902     } catch (std::exception& e) {
54903       {
54904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54905       };
54906     } catch (...) {
54907       {
54908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54909       };
54910     }
54911   }
54912   jresult = (void *)result;
54913   return jresult;
54914 }
54915
54916
54917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54918   void * jresult ;
54919   Dali::Application *arg1 = (Dali::Application *) 0 ;
54920   Dali::Application::AppSignalType *result = 0 ;
54921
54922   arg1 = (Dali::Application *)jarg1;
54923   {
54924     try {
54925       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54937       };
54938     }
54939   }
54940   jresult = (void *)result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54946   void * jresult ;
54947   Dali::Application *arg1 = (Dali::Application *) 0 ;
54948   Dali::Application::AppSignalType *result = 0 ;
54949
54950   arg1 = (Dali::Application *)jarg1;
54951   {
54952     try {
54953       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54954     } catch (std::out_of_range& e) {
54955       {
54956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54957       };
54958     } catch (std::exception& e) {
54959       {
54960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54961       };
54962     } catch (...) {
54963       {
54964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54965       };
54966     }
54967   }
54968   jresult = (void *)result;
54969   return jresult;
54970 }
54971
54972
54973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54974   void * jresult ;
54975   Dali::Application *arg1 = (Dali::Application *) 0 ;
54976   Dali::Application::AppSignalType *result = 0 ;
54977
54978   arg1 = (Dali::Application *)jarg1;
54979   {
54980     try {
54981       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54982     } catch (std::out_of_range& e) {
54983       {
54984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54985       };
54986     } catch (std::exception& e) {
54987       {
54988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54989       };
54990     } catch (...) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54993       };
54994     }
54995   }
54996   jresult = (void *)result;
54997   return jresult;
54998 }
54999
55000
55001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55002   unsigned int jresult ;
55003   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55004   bool result;
55005
55006   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55007   {
55008     try {
55009       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55010     } catch (std::out_of_range& e) {
55011       {
55012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55013       };
55014     } catch (std::exception& e) {
55015       {
55016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55017       };
55018     } catch (...) {
55019       {
55020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55021       };
55022     }
55023   }
55024   jresult = result;
55025   return jresult;
55026 }
55027
55028
55029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55030   unsigned long jresult ;
55031   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55032   std::size_t result;
55033
55034   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55035   {
55036     try {
55037       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55038     } catch (std::out_of_range& e) {
55039       {
55040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55041       };
55042     } catch (std::exception& e) {
55043       {
55044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55045       };
55046     } catch (...) {
55047       {
55048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55049       };
55050     }
55051   }
55052   jresult = (unsigned long)result;
55053   return jresult;
55054 }
55055
55056
55057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55058   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55059   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55060
55061   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55062   arg2 = (void (*)(Dali::Application &))jarg2;
55063   {
55064     try {
55065       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55066     } catch (std::out_of_range& e) {
55067       {
55068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55069       };
55070     } catch (std::exception& e) {
55071       {
55072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55073       };
55074     } catch (...) {
55075       {
55076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55077       };
55078     }
55079   }
55080 }
55081
55082
55083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55084   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55085   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55086
55087   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55088   arg2 = (void (*)(Dali::Application &))jarg2;
55089   {
55090     try {
55091       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55092     } catch (std::out_of_range& e) {
55093       {
55094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55095       };
55096     } catch (std::exception& e) {
55097       {
55098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55099       };
55100     } catch (...) {
55101       {
55102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55103       };
55104     }
55105   }
55106 }
55107
55108
55109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55110   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55111   Dali::Application *arg2 = 0 ;
55112
55113   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55114   arg2 = (Dali::Application *)jarg2;
55115   if (!arg2) {
55116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55117     return ;
55118   }
55119   {
55120     try {
55121       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55122     } catch (std::out_of_range& e) {
55123       {
55124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55125       };
55126     } catch (std::exception& e) {
55127       {
55128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55129       };
55130     } catch (...) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55133       };
55134     }
55135   }
55136 }
55137
55138
55139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55140   void * jresult ;
55141   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55142
55143   {
55144     try {
55145       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55146     } catch (std::out_of_range& e) {
55147       {
55148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55149       };
55150     } catch (std::exception& e) {
55151       {
55152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55153       };
55154     } catch (...) {
55155       {
55156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55157       };
55158     }
55159   }
55160   jresult = (void *)result;
55161   return jresult;
55162 }
55163
55164
55165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55166   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55167
55168   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55169   {
55170     try {
55171       delete arg1;
55172     } catch (std::out_of_range& e) {
55173       {
55174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55175       };
55176     } catch (std::exception& e) {
55177       {
55178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55179       };
55180     } catch (...) {
55181       {
55182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55183       };
55184     }
55185   }
55186 }
55187
55188
55189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55190   unsigned int jresult ;
55191   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55192   bool result;
55193
55194   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55195   {
55196     try {
55197       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55205       };
55206     } catch (...) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55209       };
55210     }
55211   }
55212   jresult = result;
55213   return jresult;
55214 }
55215
55216
55217 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55218   unsigned long jresult ;
55219   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55220   std::size_t result;
55221
55222   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55223   {
55224     try {
55225       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55237       };
55238     }
55239   }
55240   jresult = (unsigned long)result;
55241   return jresult;
55242 }
55243
55244
55245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55246   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55247   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55248
55249   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55250   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55251   {
55252     try {
55253       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55254     } catch (std::out_of_range& e) {
55255       {
55256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55257       };
55258     } catch (std::exception& e) {
55259       {
55260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55261       };
55262     } catch (...) {
55263       {
55264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55265       };
55266     }
55267   }
55268 }
55269
55270
55271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55272   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55273   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55274
55275   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55276   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55277   {
55278     try {
55279       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55280     } catch (std::out_of_range& e) {
55281       {
55282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55283       };
55284     } catch (std::exception& e) {
55285       {
55286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55287       };
55288     } catch (...) {
55289       {
55290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55291       };
55292     }
55293   }
55294 }
55295
55296
55297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55298   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55299   Dali::Application *arg2 = 0 ;
55300   void *arg3 = (void *) 0 ;
55301
55302   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55303   arg2 = (Dali::Application *)jarg2;
55304   if (!arg2) {
55305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55306     return ;
55307   }
55308   arg3 = jarg3;
55309   {
55310     try {
55311       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55312     } catch (std::out_of_range& e) {
55313       {
55314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55315       };
55316     } catch (std::exception& e) {
55317       {
55318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55319       };
55320     } catch (...) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55323       };
55324     }
55325   }
55326 }
55327
55328
55329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55330   void * jresult ;
55331   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55332
55333   {
55334     try {
55335       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55336     } catch (std::out_of_range& e) {
55337       {
55338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55339       };
55340     } catch (std::exception& e) {
55341       {
55342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55347       };
55348     }
55349   }
55350   jresult = (void *)result;
55351   return jresult;
55352 }
55353
55354
55355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55356   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55357
55358   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55359   {
55360     try {
55361       delete arg1;
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55369       };
55370     } catch (...) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55373       };
55374     }
55375   }
55376 }
55377
55378
55379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55380   unsigned int jresult ;
55381   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55382   bool result;
55383
55384   arg1 = (Dali::Signal< bool () > *)jarg1;
55385   {
55386     try {
55387       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55388     } catch (std::out_of_range& e) {
55389       {
55390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (std::exception& e) {
55393       {
55394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55395       };
55396     } catch (...) {
55397       {
55398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55399       };
55400     }
55401   }
55402   jresult = result;
55403   return jresult;
55404 }
55405
55406
55407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55408   unsigned long jresult ;
55409   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55410   std::size_t result;
55411
55412   arg1 = (Dali::Signal< bool () > *)jarg1;
55413   {
55414     try {
55415       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55416     } catch (std::out_of_range& e) {
55417       {
55418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55419       };
55420     } catch (std::exception& e) {
55421       {
55422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55423       };
55424     } catch (...) {
55425       {
55426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55427       };
55428     }
55429   }
55430   jresult = (unsigned long)result;
55431   return jresult;
55432 }
55433
55434
55435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55436   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55437   bool (*arg2)() = (bool (*)()) 0 ;
55438
55439   arg1 = (Dali::Signal< bool () > *)jarg1;
55440   arg2 = (bool (*)())jarg2;
55441   {
55442     try {
55443       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55444     } catch (std::out_of_range& e) {
55445       {
55446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55447       };
55448     } catch (std::exception& e) {
55449       {
55450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55451       };
55452     } catch (...) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55455       };
55456     }
55457   }
55458 }
55459
55460
55461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55462   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55463   bool (*arg2)() = (bool (*)()) 0 ;
55464
55465   arg1 = (Dali::Signal< bool () > *)jarg1;
55466   arg2 = (bool (*)())jarg2;
55467   {
55468     try {
55469       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55470     } catch (std::out_of_range& e) {
55471       {
55472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55473       };
55474     } catch (std::exception& e) {
55475       {
55476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55477       };
55478     } catch (...) {
55479       {
55480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55481       };
55482     }
55483   }
55484 }
55485
55486
55487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55488   unsigned int jresult ;
55489   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55490   bool result;
55491
55492   arg1 = (Dali::Signal< bool () > *)jarg1;
55493   {
55494     try {
55495       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55496     } catch (std::out_of_range& e) {
55497       {
55498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55499       };
55500     } catch (std::exception& e) {
55501       {
55502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55503       };
55504     } catch (...) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55507       };
55508     }
55509   }
55510   jresult = result;
55511   return jresult;
55512 }
55513
55514
55515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55516   void * jresult ;
55517   Dali::Signal< bool () > *result = 0 ;
55518
55519   {
55520     try {
55521       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55522     } catch (std::out_of_range& e) {
55523       {
55524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55525       };
55526     } catch (std::exception& e) {
55527       {
55528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55529       };
55530     } catch (...) {
55531       {
55532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55533       };
55534     }
55535   }
55536   jresult = (void *)result;
55537   return jresult;
55538 }
55539
55540
55541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55542   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55543
55544   arg1 = (Dali::Signal< bool () > *)jarg1;
55545   {
55546     try {
55547       delete arg1;
55548     } catch (std::out_of_range& e) {
55549       {
55550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55551       };
55552     } catch (std::exception& e) {
55553       {
55554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55555       };
55556     } catch (...) {
55557       {
55558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55559       };
55560     }
55561   }
55562 }
55563
55564
55565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55566   unsigned int jresult ;
55567   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55568   bool result;
55569
55570   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55571   {
55572     try {
55573       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55574     } catch (std::out_of_range& e) {
55575       {
55576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55577       };
55578     } catch (std::exception& e) {
55579       {
55580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55581       };
55582     } catch (...) {
55583       {
55584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55585       };
55586     }
55587   }
55588   jresult = result;
55589   return jresult;
55590 }
55591
55592
55593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55594   unsigned long jresult ;
55595   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55596   std::size_t result;
55597
55598   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55599   {
55600     try {
55601       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55602     } catch (std::out_of_range& e) {
55603       {
55604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55605       };
55606     } catch (std::exception& e) {
55607       {
55608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55613       };
55614     }
55615   }
55616   jresult = (unsigned long)result;
55617   return jresult;
55618 }
55619
55620
55621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55622   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55623   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55624
55625   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55626   arg2 = (void (*)(bool))jarg2;
55627   {
55628     try {
55629       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55630     } catch (std::out_of_range& e) {
55631       {
55632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55633       };
55634     } catch (std::exception& e) {
55635       {
55636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (...) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55641       };
55642     }
55643   }
55644 }
55645
55646
55647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55648   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55649   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55650
55651   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55652   arg2 = (void (*)(bool))jarg2;
55653   {
55654     try {
55655       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55656     } catch (std::out_of_range& e) {
55657       {
55658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55659       };
55660     } catch (std::exception& e) {
55661       {
55662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55663       };
55664     } catch (...) {
55665       {
55666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55667       };
55668     }
55669   }
55670 }
55671
55672
55673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55674   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55675   bool arg2 ;
55676
55677   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55678   arg2 = jarg2 ? true : false;
55679   {
55680     try {
55681       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55682     } catch (std::out_of_range& e) {
55683       {
55684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55685       };
55686     } catch (std::exception& e) {
55687       {
55688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55689       };
55690     } catch (...) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55693       };
55694     }
55695   }
55696 }
55697
55698
55699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55700   void * jresult ;
55701   Dali::Signal< void (bool) > *result = 0 ;
55702
55703   {
55704     try {
55705       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55713       };
55714     } catch (...) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55717       };
55718     }
55719   }
55720   jresult = (void *)result;
55721   return jresult;
55722 }
55723
55724
55725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55726   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55727
55728   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55729   {
55730     try {
55731       delete arg1;
55732     } catch (std::out_of_range& e) {
55733       {
55734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55735       };
55736     } catch (std::exception& e) {
55737       {
55738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55739       };
55740     } catch (...) {
55741       {
55742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55743       };
55744     }
55745   }
55746 }
55747
55748
55749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55750   int jresult ;
55751   int result;
55752
55753   {
55754     try {
55755       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55756     } catch (std::out_of_range& e) {
55757       {
55758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55759       };
55760     } catch (std::exception& e) {
55761       {
55762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55763       };
55764     } catch (...) {
55765       {
55766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55767       };
55768     }
55769   }
55770   jresult = (int)result;
55771   return jresult;
55772 }
55773
55774
55775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55776   int jresult ;
55777   int result;
55778
55779   {
55780     try {
55781       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55782     } catch (std::out_of_range& e) {
55783       {
55784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55785       };
55786     } catch (std::exception& e) {
55787       {
55788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55789       };
55790     } catch (...) {
55791       {
55792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55793       };
55794     }
55795   }
55796   jresult = (int)result;
55797   return jresult;
55798 }
55799
55800
55801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55802   int jresult ;
55803   int result;
55804
55805   {
55806     try {
55807       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55808     } catch (std::out_of_range& e) {
55809       {
55810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55811       };
55812     } catch (std::exception& e) {
55813       {
55814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55815       };
55816     } catch (...) {
55817       {
55818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55819       };
55820     }
55821   }
55822   jresult = (int)result;
55823   return jresult;
55824 }
55825
55826
55827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55828   int jresult ;
55829   int result;
55830
55831   {
55832     try {
55833       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55841       };
55842     } catch (...) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55845       };
55846     }
55847   }
55848   jresult = (int)result;
55849   return jresult;
55850 }
55851
55852
55853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55854   int jresult ;
55855   int result;
55856
55857   {
55858     try {
55859       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55867       };
55868     } catch (...) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55871       };
55872     }
55873   }
55874   jresult = (int)result;
55875   return jresult;
55876 }
55877
55878
55879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55880   int jresult ;
55881   int result;
55882
55883   {
55884     try {
55885       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55886     } catch (std::out_of_range& e) {
55887       {
55888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55889       };
55890     } catch (std::exception& e) {
55891       {
55892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55893       };
55894     } catch (...) {
55895       {
55896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55897       };
55898     }
55899   }
55900   jresult = (int)result;
55901   return jresult;
55902 }
55903
55904
55905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55906   int jresult ;
55907   int result;
55908
55909   {
55910     try {
55911       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55912     } catch (std::out_of_range& e) {
55913       {
55914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55915       };
55916     } catch (std::exception& e) {
55917       {
55918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55919       };
55920     } catch (...) {
55921       {
55922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55923       };
55924     }
55925   }
55926   jresult = (int)result;
55927   return jresult;
55928 }
55929
55930
55931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55932   int jresult ;
55933   int result;
55934
55935   {
55936     try {
55937       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55938     } catch (std::out_of_range& e) {
55939       {
55940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (std::exception& e) {
55943       {
55944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55945       };
55946     } catch (...) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55949       };
55950     }
55951   }
55952   jresult = (int)result;
55953   return jresult;
55954 }
55955
55956
55957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55958   int jresult ;
55959   int result;
55960
55961   {
55962     try {
55963       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55964     } catch (std::out_of_range& e) {
55965       {
55966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55967       };
55968     } catch (std::exception& e) {
55969       {
55970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55971       };
55972     } catch (...) {
55973       {
55974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55975       };
55976     }
55977   }
55978   jresult = (int)result;
55979   return jresult;
55980 }
55981
55982
55983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55984   int jresult ;
55985   int result;
55986
55987   {
55988     try {
55989       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55990     } catch (std::out_of_range& e) {
55991       {
55992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55993       };
55994     } catch (std::exception& e) {
55995       {
55996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55997       };
55998     } catch (...) {
55999       {
56000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56001       };
56002     }
56003   }
56004   jresult = (int)result;
56005   return jresult;
56006 }
56007
56008
56009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56010   int jresult ;
56011   int result;
56012
56013   {
56014     try {
56015       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56016     } catch (std::out_of_range& e) {
56017       {
56018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56019       };
56020     } catch (std::exception& e) {
56021       {
56022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56023       };
56024     } catch (...) {
56025       {
56026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56027       };
56028     }
56029   }
56030   jresult = (int)result;
56031   return jresult;
56032 }
56033
56034
56035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56036   int jresult ;
56037   int result;
56038
56039   {
56040     try {
56041       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56042     } catch (std::out_of_range& e) {
56043       {
56044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (std::exception& e) {
56047       {
56048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56049       };
56050     } catch (...) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56053       };
56054     }
56055   }
56056   jresult = (int)result;
56057   return jresult;
56058 }
56059
56060
56061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56062   int jresult ;
56063   int result;
56064
56065   {
56066     try {
56067       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56068     } catch (std::out_of_range& e) {
56069       {
56070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56071       };
56072     } catch (std::exception& e) {
56073       {
56074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56075       };
56076     } catch (...) {
56077       {
56078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56079       };
56080     }
56081   }
56082   jresult = (int)result;
56083   return jresult;
56084 }
56085
56086
56087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56088   int jresult ;
56089   int result;
56090
56091   {
56092     try {
56093       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56094     } catch (std::out_of_range& e) {
56095       {
56096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56097       };
56098     } catch (std::exception& e) {
56099       {
56100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56101       };
56102     } catch (...) {
56103       {
56104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56105       };
56106     }
56107   }
56108   jresult = (int)result;
56109   return jresult;
56110 }
56111
56112
56113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56114   int jresult ;
56115   int result;
56116
56117   {
56118     try {
56119       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56120     } catch (std::out_of_range& e) {
56121       {
56122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56123       };
56124     } catch (std::exception& e) {
56125       {
56126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56127       };
56128     } catch (...) {
56129       {
56130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56131       };
56132     }
56133   }
56134   jresult = (int)result;
56135   return jresult;
56136 }
56137
56138
56139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56140   int jresult ;
56141   int result;
56142
56143   {
56144     try {
56145       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56146     } catch (std::out_of_range& e) {
56147       {
56148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (std::exception& e) {
56151       {
56152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56153       };
56154     } catch (...) {
56155       {
56156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56157       };
56158     }
56159   }
56160   jresult = (int)result;
56161   return jresult;
56162 }
56163
56164
56165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56166   int jresult ;
56167   int result;
56168
56169   {
56170     try {
56171       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56172     } catch (std::out_of_range& e) {
56173       {
56174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56175       };
56176     } catch (std::exception& e) {
56177       {
56178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56179       };
56180     } catch (...) {
56181       {
56182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56183       };
56184     }
56185   }
56186   jresult = (int)result;
56187   return jresult;
56188 }
56189
56190
56191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56192   int jresult ;
56193   int result;
56194
56195   {
56196     try {
56197       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56198     } catch (std::out_of_range& e) {
56199       {
56200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56201       };
56202     } catch (std::exception& e) {
56203       {
56204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56205       };
56206     } catch (...) {
56207       {
56208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56209       };
56210     }
56211   }
56212   jresult = (int)result;
56213   return jresult;
56214 }
56215
56216
56217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56218   int jresult ;
56219   int result;
56220
56221   {
56222     try {
56223       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56224     } catch (std::out_of_range& e) {
56225       {
56226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56227       };
56228     } catch (std::exception& e) {
56229       {
56230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56231       };
56232     } catch (...) {
56233       {
56234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56235       };
56236     }
56237   }
56238   jresult = (int)result;
56239   return jresult;
56240 }
56241
56242
56243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56244   int jresult ;
56245   int result;
56246
56247   {
56248     try {
56249       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56250     } catch (std::out_of_range& e) {
56251       {
56252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56253       };
56254     } catch (std::exception& e) {
56255       {
56256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56257       };
56258     } catch (...) {
56259       {
56260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56261       };
56262     }
56263   }
56264   jresult = (int)result;
56265   return jresult;
56266 }
56267
56268
56269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56270   int jresult ;
56271   int result;
56272
56273   {
56274     try {
56275       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56276     } catch (std::out_of_range& e) {
56277       {
56278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56279       };
56280     } catch (std::exception& e) {
56281       {
56282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56283       };
56284     } catch (...) {
56285       {
56286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56287       };
56288     }
56289   }
56290   jresult = (int)result;
56291   return jresult;
56292 }
56293
56294
56295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56296   int jresult ;
56297   int result;
56298
56299   {
56300     try {
56301       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56302     } catch (std::out_of_range& e) {
56303       {
56304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56305       };
56306     } catch (std::exception& e) {
56307       {
56308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56309       };
56310     } catch (...) {
56311       {
56312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56313       };
56314     }
56315   }
56316   jresult = (int)result;
56317   return jresult;
56318 }
56319
56320
56321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56322   int jresult ;
56323   int result;
56324
56325   {
56326     try {
56327       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56328     } catch (std::out_of_range& e) {
56329       {
56330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56331       };
56332     } catch (std::exception& e) {
56333       {
56334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56335       };
56336     } catch (...) {
56337       {
56338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56339       };
56340     }
56341   }
56342   jresult = (int)result;
56343   return jresult;
56344 }
56345
56346
56347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56348   int jresult ;
56349   int result;
56350
56351   {
56352     try {
56353       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56354     } catch (std::out_of_range& e) {
56355       {
56356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56357       };
56358     } catch (std::exception& e) {
56359       {
56360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56361       };
56362     } catch (...) {
56363       {
56364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56365       };
56366     }
56367   }
56368   jresult = (int)result;
56369   return jresult;
56370 }
56371
56372
56373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56374   int jresult ;
56375   int result;
56376
56377   {
56378     try {
56379       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56380     } catch (std::out_of_range& e) {
56381       {
56382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56383       };
56384     } catch (std::exception& e) {
56385       {
56386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56387       };
56388     } catch (...) {
56389       {
56390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56391       };
56392     }
56393   }
56394   jresult = (int)result;
56395   return jresult;
56396 }
56397
56398
56399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56400   int jresult ;
56401   int result;
56402
56403   {
56404     try {
56405       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56406     } catch (std::out_of_range& e) {
56407       {
56408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56409       };
56410     } catch (std::exception& e) {
56411       {
56412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56413       };
56414     } catch (...) {
56415       {
56416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56417       };
56418     }
56419   }
56420   jresult = (int)result;
56421   return jresult;
56422 }
56423
56424
56425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56426   int jresult ;
56427   int result;
56428
56429   {
56430     try {
56431       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56432     } catch (std::out_of_range& e) {
56433       {
56434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (std::exception& e) {
56437       {
56438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56439       };
56440     } catch (...) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56443       };
56444     }
56445   }
56446   jresult = (int)result;
56447   return jresult;
56448 }
56449
56450
56451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56452   int jresult ;
56453   int result;
56454
56455   {
56456     try {
56457       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56458     } catch (std::out_of_range& e) {
56459       {
56460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (std::exception& e) {
56463       {
56464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472   jresult = (int)result;
56473   return jresult;
56474 }
56475
56476
56477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56478   int jresult ;
56479   int result;
56480
56481   {
56482     try {
56483       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56484     } catch (std::out_of_range& e) {
56485       {
56486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56487       };
56488     } catch (std::exception& e) {
56489       {
56490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (...) {
56493       {
56494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56495       };
56496     }
56497   }
56498   jresult = (int)result;
56499   return jresult;
56500 }
56501
56502
56503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56504   int jresult ;
56505   int result;
56506
56507   {
56508     try {
56509       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56510     } catch (std::out_of_range& e) {
56511       {
56512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (std::exception& e) {
56515       {
56516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56517       };
56518     } catch (...) {
56519       {
56520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56521       };
56522     }
56523   }
56524   jresult = (int)result;
56525   return jresult;
56526 }
56527
56528
56529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56530   int jresult ;
56531   int result;
56532
56533   {
56534     try {
56535       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56543       };
56544     } catch (...) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56547       };
56548     }
56549   }
56550   jresult = (int)result;
56551   return jresult;
56552 }
56553
56554
56555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56556   int jresult ;
56557   int result;
56558
56559   {
56560     try {
56561       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56562     } catch (std::out_of_range& e) {
56563       {
56564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56565       };
56566     } catch (std::exception& e) {
56567       {
56568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56573       };
56574     }
56575   }
56576   jresult = (int)result;
56577   return jresult;
56578 }
56579
56580
56581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56582   int jresult ;
56583   int result;
56584
56585   {
56586     try {
56587       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (...) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56599       };
56600     }
56601   }
56602   jresult = (int)result;
56603   return jresult;
56604 }
56605
56606
56607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56608   int jresult ;
56609   int result;
56610
56611   {
56612     try {
56613       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56614     } catch (std::out_of_range& e) {
56615       {
56616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56617       };
56618     } catch (std::exception& e) {
56619       {
56620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56621       };
56622     } catch (...) {
56623       {
56624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56625       };
56626     }
56627   }
56628   jresult = (int)result;
56629   return jresult;
56630 }
56631
56632
56633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56634   int jresult ;
56635   int result;
56636
56637   {
56638     try {
56639       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56640     } catch (std::out_of_range& e) {
56641       {
56642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56643       };
56644     } catch (std::exception& e) {
56645       {
56646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56647       };
56648     } catch (...) {
56649       {
56650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56651       };
56652     }
56653   }
56654   jresult = (int)result;
56655   return jresult;
56656 }
56657
56658
56659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56660   int jresult ;
56661   int result;
56662
56663   {
56664     try {
56665       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56666     } catch (std::out_of_range& e) {
56667       {
56668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56669       };
56670     } catch (std::exception& e) {
56671       {
56672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56673       };
56674     } catch (...) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56677       };
56678     }
56679   }
56680   jresult = (int)result;
56681   return jresult;
56682 }
56683
56684
56685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56686   int jresult ;
56687   int result;
56688
56689   {
56690     try {
56691       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56692     } catch (std::out_of_range& e) {
56693       {
56694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56695       };
56696     } catch (std::exception& e) {
56697       {
56698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56699       };
56700     } catch (...) {
56701       {
56702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56703       };
56704     }
56705   }
56706   jresult = (int)result;
56707   return jresult;
56708 }
56709
56710
56711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56712   int jresult ;
56713   int result;
56714
56715   {
56716     try {
56717       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56718     } catch (std::out_of_range& e) {
56719       {
56720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (std::exception& e) {
56723       {
56724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (...) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56729       };
56730     }
56731   }
56732   jresult = (int)result;
56733   return jresult;
56734 }
56735
56736
56737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56738   int jresult ;
56739   int result;
56740
56741   {
56742     try {
56743       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758   jresult = (int)result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56764   int jresult ;
56765   int result;
56766
56767   {
56768     try {
56769       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56770     } catch (std::out_of_range& e) {
56771       {
56772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56773       };
56774     } catch (std::exception& e) {
56775       {
56776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (...) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56781       };
56782     }
56783   }
56784   jresult = (int)result;
56785   return jresult;
56786 }
56787
56788
56789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56790   int jresult ;
56791   int result;
56792
56793   {
56794     try {
56795       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56796     } catch (std::out_of_range& e) {
56797       {
56798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56799       };
56800     } catch (std::exception& e) {
56801       {
56802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56803       };
56804     } catch (...) {
56805       {
56806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56807       };
56808     }
56809   }
56810   jresult = (int)result;
56811   return jresult;
56812 }
56813
56814
56815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56816   int jresult ;
56817   int result;
56818
56819   {
56820     try {
56821       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56822     } catch (std::out_of_range& e) {
56823       {
56824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56825       };
56826     } catch (std::exception& e) {
56827       {
56828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56829       };
56830     } catch (...) {
56831       {
56832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56833       };
56834     }
56835   }
56836   jresult = (int)result;
56837   return jresult;
56838 }
56839
56840
56841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56842   int jresult ;
56843   int result;
56844
56845   {
56846     try {
56847       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56848     } catch (std::out_of_range& e) {
56849       {
56850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56851       };
56852     } catch (std::exception& e) {
56853       {
56854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56855       };
56856     } catch (...) {
56857       {
56858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56859       };
56860     }
56861   }
56862   jresult = (int)result;
56863   return jresult;
56864 }
56865
56866
56867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56868   int jresult ;
56869   int result;
56870
56871   {
56872     try {
56873       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56885       };
56886     }
56887   }
56888   jresult = (int)result;
56889   return jresult;
56890 }
56891
56892
56893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56894   int jresult ;
56895   int result;
56896
56897   {
56898     try {
56899       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (...) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56911       };
56912     }
56913   }
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (...) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56937       };
56938     }
56939   }
56940   jresult = (int)result;
56941   return jresult;
56942 }
56943
56944
56945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56946   int jresult ;
56947   int result;
56948
56949   {
56950     try {
56951       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56963       };
56964     }
56965   }
56966   jresult = (int)result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56972   int jresult ;
56973   int result;
56974
56975   {
56976     try {
56977       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56978     } catch (std::out_of_range& e) {
56979       {
56980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (std::exception& e) {
56983       {
56984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56985       };
56986     } catch (...) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56989       };
56990     }
56991   }
56992   jresult = (int)result;
56993   return jresult;
56994 }
56995
56996
56997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56998   int jresult ;
56999   int result;
57000
57001   {
57002     try {
57003       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57004     } catch (std::out_of_range& e) {
57005       {
57006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (std::exception& e) {
57009       {
57010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57015       };
57016     }
57017   }
57018   jresult = (int)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57024   int jresult ;
57025   int result;
57026
57027   {
57028     try {
57029       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57030     } catch (std::out_of_range& e) {
57031       {
57032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57033       };
57034     } catch (std::exception& e) {
57035       {
57036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57037       };
57038     } catch (...) {
57039       {
57040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57041       };
57042     }
57043   }
57044   jresult = (int)result;
57045   return jresult;
57046 }
57047
57048
57049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57050   int jresult ;
57051   int result;
57052
57053   {
57054     try {
57055       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57056     } catch (std::out_of_range& e) {
57057       {
57058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57059       };
57060     } catch (std::exception& e) {
57061       {
57062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57063       };
57064     } catch (...) {
57065       {
57066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57067       };
57068     }
57069   }
57070   jresult = (int)result;
57071   return jresult;
57072 }
57073
57074
57075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57076   int jresult ;
57077   int result;
57078
57079   {
57080     try {
57081       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57082     } catch (std::out_of_range& e) {
57083       {
57084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57085       };
57086     } catch (std::exception& e) {
57087       {
57088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (...) {
57091       {
57092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57093       };
57094     }
57095   }
57096   jresult = (int)result;
57097   return jresult;
57098 }
57099
57100
57101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57102   int jresult ;
57103   int result;
57104
57105   {
57106     try {
57107       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57108     } catch (std::out_of_range& e) {
57109       {
57110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (std::exception& e) {
57113       {
57114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (...) {
57117       {
57118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57119       };
57120     }
57121   }
57122   jresult = (int)result;
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57128   int jresult ;
57129   int result;
57130
57131   {
57132     try {
57133       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57134     } catch (std::out_of_range& e) {
57135       {
57136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57137       };
57138     } catch (std::exception& e) {
57139       {
57140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57141       };
57142     } catch (...) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57145       };
57146     }
57147   }
57148   jresult = (int)result;
57149   return jresult;
57150 }
57151
57152
57153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57154   int jresult ;
57155   int result;
57156
57157   {
57158     try {
57159       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57160     } catch (std::out_of_range& e) {
57161       {
57162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (std::exception& e) {
57165       {
57166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (...) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57171       };
57172     }
57173   }
57174   jresult = (int)result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57180   int jresult ;
57181   int result;
57182
57183   {
57184     try {
57185       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57193       };
57194     } catch (...) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57197       };
57198     }
57199   }
57200   jresult = (int)result;
57201   return jresult;
57202 }
57203
57204
57205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57206   int jresult ;
57207   int result;
57208
57209   {
57210     try {
57211       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57212     } catch (std::out_of_range& e) {
57213       {
57214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57215       };
57216     } catch (std::exception& e) {
57217       {
57218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57219       };
57220     } catch (...) {
57221       {
57222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57223       };
57224     }
57225   }
57226   jresult = (int)result;
57227   return jresult;
57228 }
57229
57230
57231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57232   void * jresult ;
57233   Dali::Toolkit::Builder *result = 0 ;
57234
57235   {
57236     try {
57237       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57238     } catch (std::out_of_range& e) {
57239       {
57240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57241       };
57242     } catch (std::exception& e) {
57243       {
57244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57245       };
57246     } catch (...) {
57247       {
57248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57249       };
57250     }
57251   }
57252   jresult = (void *)result;
57253   return jresult;
57254 }
57255
57256
57257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57258   void * jresult ;
57259   Dali::Toolkit::Builder result;
57260
57261   {
57262     try {
57263       result = Dali::Toolkit::Builder::New();
57264     } catch (std::out_of_range& e) {
57265       {
57266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (std::exception& e) {
57269       {
57270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57271       };
57272     } catch (...) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57275       };
57276     }
57277   }
57278   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57279   return jresult;
57280 }
57281
57282
57283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57284   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57285
57286   arg1 = (Dali::Toolkit::Builder *)jarg1;
57287   {
57288     try {
57289       delete arg1;
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (...) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57301       };
57302     }
57303   }
57304 }
57305
57306
57307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57308   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57309   std::string *arg2 = 0 ;
57310   Dali::Toolkit::Builder::UIFormat arg3 ;
57311
57312   arg1 = (Dali::Toolkit::Builder *)jarg1;
57313   if (!jarg2) {
57314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57315     return ;
57316   }
57317   std::string arg2_str(jarg2);
57318   arg2 = &arg2_str;
57319   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57320   {
57321     try {
57322       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57323     } catch (std::out_of_range& e) {
57324       {
57325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57326       };
57327     } catch (std::exception& e) {
57328       {
57329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57334       };
57335     }
57336   }
57337
57338   //argout typemap for const std::string&
57339
57340 }
57341
57342
57343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57344   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57345   std::string *arg2 = 0 ;
57346
57347   arg1 = (Dali::Toolkit::Builder *)jarg1;
57348   if (!jarg2) {
57349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57350     return ;
57351   }
57352   std::string arg2_str(jarg2);
57353   arg2 = &arg2_str;
57354   {
57355     try {
57356       (arg1)->LoadFromString((std::string const &)*arg2);
57357     } catch (std::out_of_range& e) {
57358       {
57359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57360       };
57361     } catch (std::exception& e) {
57362       {
57363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57364       };
57365     } catch (...) {
57366       {
57367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57368       };
57369     }
57370   }
57371
57372   //argout typemap for const std::string&
57373
57374 }
57375
57376
57377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57378   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57379   Dali::Property::Map *arg2 = 0 ;
57380
57381   arg1 = (Dali::Toolkit::Builder *)jarg1;
57382   arg2 = (Dali::Property::Map *)jarg2;
57383   if (!arg2) {
57384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57385     return ;
57386   }
57387   {
57388     try {
57389       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57390     } catch (std::out_of_range& e) {
57391       {
57392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57393       };
57394     } catch (std::exception& e) {
57395       {
57396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57397       };
57398     } catch (...) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57401       };
57402     }
57403   }
57404 }
57405
57406
57407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57408   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57409   std::string *arg2 = 0 ;
57410   Dali::Property::Value *arg3 = 0 ;
57411
57412   arg1 = (Dali::Toolkit::Builder *)jarg1;
57413   if (!jarg2) {
57414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57415     return ;
57416   }
57417   std::string arg2_str(jarg2);
57418   arg2 = &arg2_str;
57419   arg3 = (Dali::Property::Value *)jarg3;
57420   if (!arg3) {
57421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57422     return ;
57423   }
57424   {
57425     try {
57426       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57427     } catch (std::out_of_range& e) {
57428       {
57429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57430       };
57431     } catch (std::exception& e) {
57432       {
57433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57434       };
57435     } catch (...) {
57436       {
57437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57438       };
57439     }
57440   }
57441
57442   //argout typemap for const std::string&
57443
57444 }
57445
57446
57447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57448   void * jresult ;
57449   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57450   Dali::Property::Map *result = 0 ;
57451
57452   arg1 = (Dali::Toolkit::Builder *)jarg1;
57453   {
57454     try {
57455       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57456     } catch (std::out_of_range& e) {
57457       {
57458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57459       };
57460     } catch (std::exception& e) {
57461       {
57462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57463       };
57464     } catch (...) {
57465       {
57466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57467       };
57468     }
57469   }
57470   jresult = (void *)result;
57471   return jresult;
57472 }
57473
57474
57475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57476   void * jresult ;
57477   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57478   std::string *arg2 = 0 ;
57479   Dali::Property::Value *result = 0 ;
57480
57481   arg1 = (Dali::Toolkit::Builder *)jarg1;
57482   if (!jarg2) {
57483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57484     return 0;
57485   }
57486   std::string arg2_str(jarg2);
57487   arg2 = &arg2_str;
57488   {
57489     try {
57490       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57491     } catch (std::out_of_range& e) {
57492       {
57493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57494       };
57495     } catch (std::exception& e) {
57496       {
57497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57498       };
57499     } catch (...) {
57500       {
57501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57502       };
57503     }
57504   }
57505   jresult = (void *)result;
57506
57507   //argout typemap for const std::string&
57508
57509   return jresult;
57510 }
57511
57512
57513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57514   void * jresult ;
57515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57516   std::string *arg2 = 0 ;
57517   Dali::Animation result;
57518
57519   arg1 = (Dali::Toolkit::Builder *)jarg1;
57520   if (!jarg2) {
57521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57522     return 0;
57523   }
57524   std::string arg2_str(jarg2);
57525   arg2 = &arg2_str;
57526   {
57527     try {
57528       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57529     } catch (std::out_of_range& e) {
57530       {
57531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57532       };
57533     } catch (std::exception& e) {
57534       {
57535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57536       };
57537     } catch (...) {
57538       {
57539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57540       };
57541     }
57542   }
57543   jresult = new Dali::Animation((const Dali::Animation &)result);
57544
57545   //argout typemap for const std::string&
57546
57547   return jresult;
57548 }
57549
57550
57551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57552   void * jresult ;
57553   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57554   std::string *arg2 = 0 ;
57555   Dali::Property::Map *arg3 = 0 ;
57556   Dali::Animation result;
57557
57558   arg1 = (Dali::Toolkit::Builder *)jarg1;
57559   if (!jarg2) {
57560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57561     return 0;
57562   }
57563   std::string arg2_str(jarg2);
57564   arg2 = &arg2_str;
57565   arg3 = (Dali::Property::Map *)jarg3;
57566   if (!arg3) {
57567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57568     return 0;
57569   }
57570   {
57571     try {
57572       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57573     } catch (std::out_of_range& e) {
57574       {
57575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57576       };
57577     } catch (std::exception& e) {
57578       {
57579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57580       };
57581     } catch (...) {
57582       {
57583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57584       };
57585     }
57586   }
57587   jresult = new Dali::Animation((const Dali::Animation &)result);
57588
57589   //argout typemap for const std::string&
57590
57591   return jresult;
57592 }
57593
57594
57595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57596   void * jresult ;
57597   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57598   std::string *arg2 = 0 ;
57599   Dali::Actor arg3 ;
57600   Dali::Actor *argp3 ;
57601   Dali::Animation result;
57602
57603   arg1 = (Dali::Toolkit::Builder *)jarg1;
57604   if (!jarg2) {
57605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57606     return 0;
57607   }
57608   std::string arg2_str(jarg2);
57609   arg2 = &arg2_str;
57610   argp3 = (Dali::Actor *)jarg3;
57611   if (!argp3) {
57612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57613     return 0;
57614   }
57615   arg3 = *argp3;
57616   {
57617     try {
57618       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57619     } catch (std::out_of_range& e) {
57620       {
57621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57622       };
57623     } catch (std::exception& e) {
57624       {
57625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57626       };
57627     } catch (...) {
57628       {
57629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57630       };
57631     }
57632   }
57633   jresult = new Dali::Animation((const Dali::Animation &)result);
57634
57635   //argout typemap for const std::string&
57636
57637   return jresult;
57638 }
57639
57640
57641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57642   void * jresult ;
57643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57644   std::string *arg2 = 0 ;
57645   Dali::Property::Map *arg3 = 0 ;
57646   Dali::Actor arg4 ;
57647   Dali::Actor *argp4 ;
57648   Dali::Animation result;
57649
57650   arg1 = (Dali::Toolkit::Builder *)jarg1;
57651   if (!jarg2) {
57652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57653     return 0;
57654   }
57655   std::string arg2_str(jarg2);
57656   arg2 = &arg2_str;
57657   arg3 = (Dali::Property::Map *)jarg3;
57658   if (!arg3) {
57659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57660     return 0;
57661   }
57662   argp4 = (Dali::Actor *)jarg4;
57663   if (!argp4) {
57664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57665     return 0;
57666   }
57667   arg4 = *argp4;
57668   {
57669     try {
57670       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57671     } catch (std::out_of_range& e) {
57672       {
57673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57674       };
57675     } catch (std::exception& e) {
57676       {
57677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57678       };
57679     } catch (...) {
57680       {
57681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57682       };
57683     }
57684   }
57685   jresult = new Dali::Animation((const Dali::Animation &)result);
57686
57687   //argout typemap for const std::string&
57688
57689   return jresult;
57690 }
57691
57692
57693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57694   void * jresult ;
57695   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57696   std::string *arg2 = 0 ;
57697   Dali::BaseHandle result;
57698
57699   arg1 = (Dali::Toolkit::Builder *)jarg1;
57700   if (!jarg2) {
57701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57702     return 0;
57703   }
57704   std::string arg2_str(jarg2);
57705   arg2 = &arg2_str;
57706   {
57707     try {
57708       result = (arg1)->Create((std::string const &)*arg2);
57709     } catch (std::out_of_range& e) {
57710       {
57711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57712       };
57713     } catch (std::exception& e) {
57714       {
57715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57716       };
57717     } catch (...) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57720       };
57721     }
57722   }
57723   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57724
57725   //argout typemap for const std::string&
57726
57727   return jresult;
57728 }
57729
57730
57731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57732   void * jresult ;
57733   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57734   std::string *arg2 = 0 ;
57735   Dali::Property::Map *arg3 = 0 ;
57736   Dali::BaseHandle result;
57737
57738   arg1 = (Dali::Toolkit::Builder *)jarg1;
57739   if (!jarg2) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57741     return 0;
57742   }
57743   std::string arg2_str(jarg2);
57744   arg2 = &arg2_str;
57745   arg3 = (Dali::Property::Map *)jarg3;
57746   if (!arg3) {
57747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57748     return 0;
57749   }
57750   {
57751     try {
57752       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57753     } catch (std::out_of_range& e) {
57754       {
57755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57756       };
57757     } catch (std::exception& e) {
57758       {
57759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (...) {
57762       {
57763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57764       };
57765     }
57766   }
57767   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57768
57769   //argout typemap for const std::string&
57770
57771   return jresult;
57772 }
57773
57774
57775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57776   void * jresult ;
57777   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57778   std::string *arg2 = 0 ;
57779   Dali::BaseHandle result;
57780
57781   arg1 = (Dali::Toolkit::Builder *)jarg1;
57782   if (!jarg2) {
57783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57784     return 0;
57785   }
57786   std::string arg2_str(jarg2);
57787   arg2 = &arg2_str;
57788   {
57789     try {
57790       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57791     } catch (std::out_of_range& e) {
57792       {
57793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57794       };
57795     } catch (std::exception& e) {
57796       {
57797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57798       };
57799     } catch (...) {
57800       {
57801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57802       };
57803     }
57804   }
57805   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57806
57807   //argout typemap for const std::string&
57808
57809   return jresult;
57810 }
57811
57812
57813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57814   unsigned int jresult ;
57815   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57816   std::string *arg2 = 0 ;
57817   Dali::Handle *arg3 = 0 ;
57818   bool result;
57819
57820   arg1 = (Dali::Toolkit::Builder *)jarg1;
57821   if (!jarg2) {
57822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57823     return 0;
57824   }
57825   std::string arg2_str(jarg2);
57826   arg2 = &arg2_str;
57827   arg3 = (Dali::Handle *)jarg3;
57828   if (!arg3) {
57829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57830     return 0;
57831   }
57832   {
57833     try {
57834       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (...) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57846       };
57847     }
57848   }
57849   jresult = result;
57850
57851   //argout typemap for const std::string&
57852
57853   return jresult;
57854 }
57855
57856
57857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57858   unsigned int jresult ;
57859   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57860   Dali::Handle *arg2 = 0 ;
57861   std::string *arg3 = 0 ;
57862   bool result;
57863
57864   arg1 = (Dali::Toolkit::Builder *)jarg1;
57865   arg2 = (Dali::Handle *)jarg2;
57866   if (!arg2) {
57867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57868     return 0;
57869   }
57870   if (!jarg3) {
57871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57872     return 0;
57873   }
57874   std::string arg3_str(jarg3);
57875   arg3 = &arg3_str;
57876   {
57877     try {
57878       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57879     } catch (std::out_of_range& e) {
57880       {
57881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (std::exception& e) {
57884       {
57885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57886       };
57887     } catch (...) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57890       };
57891     }
57892   }
57893   jresult = result;
57894
57895   //argout typemap for const std::string&
57896
57897   return jresult;
57898 }
57899
57900
57901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57902   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57903   Dali::Actor arg2 ;
57904   Dali::Actor *argp2 ;
57905
57906   arg1 = (Dali::Toolkit::Builder *)jarg1;
57907   argp2 = (Dali::Actor *)jarg2;
57908   if (!argp2) {
57909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57910     return ;
57911   }
57912   arg2 = *argp2;
57913   {
57914     try {
57915       (arg1)->AddActors(arg2);
57916     } catch (std::out_of_range& e) {
57917       {
57918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57919       };
57920     } catch (std::exception& e) {
57921       {
57922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57923       };
57924     } catch (...) {
57925       {
57926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57927       };
57928     }
57929   }
57930 }
57931
57932
57933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57934   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57935   std::string *arg2 = 0 ;
57936   Dali::Actor arg3 ;
57937   Dali::Actor *argp3 ;
57938
57939   arg1 = (Dali::Toolkit::Builder *)jarg1;
57940   if (!jarg2) {
57941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57942     return ;
57943   }
57944   std::string arg2_str(jarg2);
57945   arg2 = &arg2_str;
57946   argp3 = (Dali::Actor *)jarg3;
57947   if (!argp3) {
57948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57949     return ;
57950   }
57951   arg3 = *argp3;
57952   {
57953     try {
57954       (arg1)->AddActors((std::string const &)*arg2,arg3);
57955     } catch (std::out_of_range& e) {
57956       {
57957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57958       };
57959     } catch (std::exception& e) {
57960       {
57961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57962       };
57963     } catch (...) {
57964       {
57965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57966       };
57967     }
57968   }
57969
57970   //argout typemap for const std::string&
57971
57972 }
57973
57974
57975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57976   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57977   std::string *arg2 = 0 ;
57978
57979   arg1 = (Dali::Toolkit::Builder *)jarg1;
57980   if (!jarg2) {
57981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57982     return ;
57983   }
57984   std::string arg2_str(jarg2);
57985   arg2 = &arg2_str;
57986   {
57987     try {
57988       (arg1)->CreateRenderTask((std::string const &)*arg2);
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57996       };
57997     } catch (...) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58000       };
58001     }
58002   }
58003
58004   //argout typemap for const std::string&
58005
58006 }
58007
58008
58009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58010   void * jresult ;
58011   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58012   std::string *arg2 = 0 ;
58013   Dali::FrameBufferImage result;
58014
58015   arg1 = (Dali::Toolkit::Builder *)jarg1;
58016   if (!jarg2) {
58017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58018     return 0;
58019   }
58020   std::string arg2_str(jarg2);
58021   arg2 = &arg2_str;
58022   {
58023     try {
58024       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58025     } catch (std::out_of_range& e) {
58026       {
58027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58028       };
58029     } catch (std::exception& e) {
58030       {
58031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58032       };
58033     } catch (...) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58036       };
58037     }
58038   }
58039   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58040
58041   //argout typemap for const std::string&
58042
58043   return jresult;
58044 }
58045
58046
58047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58048   void * jresult ;
58049   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58050   std::string *arg2 = 0 ;
58051   Dali::Path result;
58052
58053   arg1 = (Dali::Toolkit::Builder *)jarg1;
58054   if (!jarg2) {
58055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58056     return 0;
58057   }
58058   std::string arg2_str(jarg2);
58059   arg2 = &arg2_str;
58060   {
58061     try {
58062       result = (arg1)->GetPath((std::string const &)*arg2);
58063     } catch (std::out_of_range& e) {
58064       {
58065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58066       };
58067     } catch (std::exception& e) {
58068       {
58069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58070       };
58071     } catch (...) {
58072       {
58073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58074       };
58075     }
58076   }
58077   jresult = new Dali::Path((const Dali::Path &)result);
58078
58079   //argout typemap for const std::string&
58080
58081   return jresult;
58082 }
58083
58084
58085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58086   void * jresult ;
58087   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58088   std::string *arg2 = 0 ;
58089   Dali::PathConstrainer result;
58090
58091   arg1 = (Dali::Toolkit::Builder *)jarg1;
58092   if (!jarg2) {
58093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58094     return 0;
58095   }
58096   std::string arg2_str(jarg2);
58097   arg2 = &arg2_str;
58098   {
58099     try {
58100       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58101     } catch (std::out_of_range& e) {
58102       {
58103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58104       };
58105     } catch (std::exception& e) {
58106       {
58107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58108       };
58109     } catch (...) {
58110       {
58111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58112       };
58113     }
58114   }
58115   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58116
58117   //argout typemap for const std::string&
58118
58119   return jresult;
58120 }
58121
58122
58123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58124   void * jresult ;
58125   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58126   std::string *arg2 = 0 ;
58127   Dali::LinearConstrainer result;
58128
58129   arg1 = (Dali::Toolkit::Builder *)jarg1;
58130   if (!jarg2) {
58131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58132     return 0;
58133   }
58134   std::string arg2_str(jarg2);
58135   arg2 = &arg2_str;
58136   {
58137     try {
58138       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58139     } catch (std::out_of_range& e) {
58140       {
58141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58142       };
58143     } catch (std::exception& e) {
58144       {
58145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58146       };
58147     } catch (...) {
58148       {
58149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58150       };
58151     }
58152   }
58153   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58154
58155   //argout typemap for const std::string&
58156
58157   return jresult;
58158 }
58159
58160
58161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58162   void * jresult ;
58163   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58164   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58165
58166   arg1 = (Dali::Toolkit::Builder *)jarg1;
58167   {
58168     try {
58169       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184   jresult = (void *)result;
58185   return jresult;
58186 }
58187
58188
58189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58190   void * jresult ;
58191   Dali::Toolkit::TransitionData *result = 0 ;
58192
58193   {
58194     try {
58195       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58196     } catch (std::out_of_range& e) {
58197       {
58198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58199       };
58200     } catch (std::exception& e) {
58201       {
58202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (...) {
58205       {
58206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58207       };
58208     }
58209   }
58210   jresult = (void *)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58216   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58217
58218   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58219   {
58220     try {
58221       delete arg1;
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58233       };
58234     }
58235   }
58236 }
58237
58238
58239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58240   void * jresult ;
58241   Dali::Property::Map *arg1 = 0 ;
58242   Dali::Toolkit::TransitionData result;
58243
58244   arg1 = (Dali::Property::Map *)jarg1;
58245   if (!arg1) {
58246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58247     return 0;
58248   }
58249   {
58250     try {
58251       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (...) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58263       };
58264     }
58265   }
58266   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58267   return jresult;
58268 }
58269
58270
58271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58272   void * jresult ;
58273   Dali::Property::Array *arg1 = 0 ;
58274   Dali::Toolkit::TransitionData result;
58275
58276   arg1 = (Dali::Property::Array *)jarg1;
58277   if (!arg1) {
58278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58279     return 0;
58280   }
58281   {
58282     try {
58283       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58284     } catch (std::out_of_range& e) {
58285       {
58286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58287       };
58288     } catch (std::exception& e) {
58289       {
58290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58291       };
58292     } catch (...) {
58293       {
58294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58295       };
58296     }
58297   }
58298   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58299   return jresult;
58300 }
58301
58302
58303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58304   void * jresult ;
58305   Dali::BaseHandle arg1 ;
58306   Dali::BaseHandle *argp1 ;
58307   Dali::Toolkit::TransitionData result;
58308
58309   argp1 = (Dali::BaseHandle *)jarg1;
58310   if (!argp1) {
58311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58312     return 0;
58313   }
58314   arg1 = *argp1;
58315   {
58316     try {
58317       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58318     } catch (std::out_of_range& e) {
58319       {
58320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58321       };
58322     } catch (std::exception& e) {
58323       {
58324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58325       };
58326     } catch (...) {
58327       {
58328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58329       };
58330     }
58331   }
58332   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58333   return jresult;
58334 }
58335
58336
58337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58338   void * jresult ;
58339   Dali::Toolkit::TransitionData *arg1 = 0 ;
58340   Dali::Toolkit::TransitionData *result = 0 ;
58341
58342   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58343   if (!arg1) {
58344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58345     return 0;
58346   }
58347   {
58348     try {
58349       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58350     } catch (std::out_of_range& e) {
58351       {
58352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58353       };
58354     } catch (std::exception& e) {
58355       {
58356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58357       };
58358     } catch (...) {
58359       {
58360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58361       };
58362     }
58363   }
58364   jresult = (void *)result;
58365   return jresult;
58366 }
58367
58368
58369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58370   void * jresult ;
58371   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58372   Dali::Toolkit::TransitionData *arg2 = 0 ;
58373   Dali::Toolkit::TransitionData *result = 0 ;
58374
58375   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58376   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58377   if (!arg2) {
58378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58379     return 0;
58380   }
58381   {
58382     try {
58383       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58384     } catch (std::out_of_range& e) {
58385       {
58386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58387       };
58388     } catch (std::exception& e) {
58389       {
58390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58391       };
58392     } catch (...) {
58393       {
58394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58395       };
58396     }
58397   }
58398   jresult = (void *)result;
58399   return jresult;
58400 }
58401
58402
58403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58404   unsigned long jresult ;
58405   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58406   size_t result;
58407
58408   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58409   {
58410     try {
58411       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58412     } catch (std::out_of_range& e) {
58413       {
58414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58415       };
58416     } catch (std::exception& e) {
58417       {
58418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58419       };
58420     } catch (...) {
58421       {
58422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58423       };
58424     }
58425   }
58426   jresult = (unsigned long)result;
58427   return jresult;
58428 }
58429
58430
58431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58432   void * jresult ;
58433   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58434   size_t arg2 ;
58435   Dali::Property::Map result;
58436
58437   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58438   arg2 = (size_t)jarg2;
58439   {
58440     try {
58441       result = (arg1)->GetAnimatorAt(arg2);
58442     } catch (std::out_of_range& e) {
58443       {
58444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58445       };
58446     } catch (std::exception& e) {
58447       {
58448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58449       };
58450     } catch (...) {
58451       {
58452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58453       };
58454     }
58455   }
58456   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58457   return jresult;
58458 }
58459
58460
58461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58462   void * jresult ;
58463   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58464   Dali::Toolkit::TransitionData *result = 0 ;
58465
58466   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58467   {
58468     try {
58469       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58470     } catch (std::out_of_range& e) {
58471       {
58472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58473       };
58474     } catch (std::exception& e) {
58475       {
58476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58477       };
58478     } catch (...) {
58479       {
58480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58481       };
58482     }
58483   }
58484   jresult = (void *)result;
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58490   int jresult ;
58491   int result;
58492
58493   {
58494     try {
58495       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58496     } catch (std::out_of_range& e) {
58497       {
58498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58499       };
58500     } catch (std::exception& e) {
58501       {
58502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58503       };
58504     } catch (...) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58507       };
58508     }
58509   }
58510   jresult = (int)result;
58511   return jresult;
58512 }
58513
58514
58515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58516   int jresult ;
58517   int result;
58518
58519   {
58520     try {
58521       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58522     } catch (std::out_of_range& e) {
58523       {
58524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58525       };
58526     } catch (std::exception& e) {
58527       {
58528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58529       };
58530     } catch (...) {
58531       {
58532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58533       };
58534     }
58535   }
58536   jresult = (int)result;
58537   return jresult;
58538 }
58539
58540
58541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58542   int jresult ;
58543   int result;
58544
58545   {
58546     try {
58547       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58548     } catch (std::out_of_range& e) {
58549       {
58550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58551       };
58552     } catch (std::exception& e) {
58553       {
58554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58555       };
58556     } catch (...) {
58557       {
58558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58559       };
58560     }
58561   }
58562   jresult = (int)result;
58563   return jresult;
58564 }
58565
58566
58567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58568   int jresult ;
58569   int result;
58570
58571   {
58572     try {
58573       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58574     } catch (std::out_of_range& e) {
58575       {
58576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58577       };
58578     } catch (std::exception& e) {
58579       {
58580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58581       };
58582     } catch (...) {
58583       {
58584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58585       };
58586     }
58587   }
58588   jresult = (int)result;
58589   return jresult;
58590 }
58591
58592
58593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58594   int jresult ;
58595   int result;
58596
58597   {
58598     try {
58599       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58600     } catch (std::out_of_range& e) {
58601       {
58602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58603       };
58604     } catch (std::exception& e) {
58605       {
58606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58607       };
58608     } catch (...) {
58609       {
58610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58611       };
58612     }
58613   }
58614   jresult = (int)result;
58615   return jresult;
58616 }
58617
58618
58619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58620   int jresult ;
58621   int result;
58622
58623   {
58624     try {
58625       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58626     } catch (std::out_of_range& e) {
58627       {
58628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (std::exception& e) {
58631       {
58632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58633       };
58634     } catch (...) {
58635       {
58636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58637       };
58638     }
58639   }
58640   jresult = (int)result;
58641   return jresult;
58642 }
58643
58644
58645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58646   int jresult ;
58647   int result;
58648
58649   {
58650     try {
58651       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58652     } catch (std::out_of_range& e) {
58653       {
58654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58655       };
58656     } catch (std::exception& e) {
58657       {
58658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58659       };
58660     } catch (...) {
58661       {
58662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58663       };
58664     }
58665   }
58666   jresult = (int)result;
58667   return jresult;
58668 }
58669
58670
58671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58672   int jresult ;
58673   int result;
58674
58675   {
58676     try {
58677       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58678     } catch (std::out_of_range& e) {
58679       {
58680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58681       };
58682     } catch (std::exception& e) {
58683       {
58684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58689       };
58690     }
58691   }
58692   jresult = (int)result;
58693   return jresult;
58694 }
58695
58696
58697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58698   int jresult ;
58699   int result;
58700
58701   {
58702     try {
58703       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58704     } catch (std::out_of_range& e) {
58705       {
58706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58707       };
58708     } catch (std::exception& e) {
58709       {
58710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58711       };
58712     } catch (...) {
58713       {
58714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58715       };
58716     }
58717   }
58718   jresult = (int)result;
58719   return jresult;
58720 }
58721
58722
58723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58724   int jresult ;
58725   int result;
58726
58727   {
58728     try {
58729       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58730     } catch (std::out_of_range& e) {
58731       {
58732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58733       };
58734     } catch (std::exception& e) {
58735       {
58736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58737       };
58738     } catch (...) {
58739       {
58740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58741       };
58742     }
58743   }
58744   jresult = (int)result;
58745   return jresult;
58746 }
58747
58748
58749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58750   int jresult ;
58751   int result;
58752
58753   {
58754     try {
58755       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58756     } catch (std::out_of_range& e) {
58757       {
58758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (std::exception& e) {
58761       {
58762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58763       };
58764     } catch (...) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58767       };
58768     }
58769   }
58770   jresult = (int)result;
58771   return jresult;
58772 }
58773
58774
58775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58776   int jresult ;
58777   int result;
58778
58779   {
58780     try {
58781       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58782     } catch (std::out_of_range& e) {
58783       {
58784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58785       };
58786     } catch (std::exception& e) {
58787       {
58788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58789       };
58790     } catch (...) {
58791       {
58792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58793       };
58794     }
58795   }
58796   jresult = (int)result;
58797   return jresult;
58798 }
58799
58800
58801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58802   int jresult ;
58803   int result;
58804
58805   {
58806     try {
58807       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58808     } catch (std::out_of_range& e) {
58809       {
58810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58811       };
58812     } catch (std::exception& e) {
58813       {
58814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58815       };
58816     } catch (...) {
58817       {
58818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58819       };
58820     }
58821   }
58822   jresult = (int)result;
58823   return jresult;
58824 }
58825
58826
58827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58828   int jresult ;
58829   int result;
58830
58831   {
58832     try {
58833       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58834     } catch (std::out_of_range& e) {
58835       {
58836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58837       };
58838     } catch (std::exception& e) {
58839       {
58840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58841       };
58842     } catch (...) {
58843       {
58844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58845       };
58846     }
58847   }
58848   jresult = (int)result;
58849   return jresult;
58850 }
58851
58852
58853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58854   void * jresult ;
58855   Dali::Toolkit::Control result;
58856
58857   {
58858     try {
58859       result = Dali::Toolkit::Internal::Control::New();
58860     } catch (std::out_of_range& e) {
58861       {
58862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (std::exception& e) {
58865       {
58866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58867       };
58868     } catch (...) {
58869       {
58870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58871       };
58872     }
58873   }
58874   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58875   return jresult;
58876 }
58877
58878
58879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58881   std::string *arg2 = 0 ;
58882
58883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58884   if (!jarg2) {
58885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58886     return ;
58887   }
58888   std::string arg2_str(jarg2);
58889   arg2 = &arg2_str;
58890   {
58891     try {
58892       (arg1)->SetStyleName((std::string const &)*arg2);
58893     } catch (std::out_of_range& e) {
58894       {
58895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58896       };
58897     } catch (std::exception& e) {
58898       {
58899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58900       };
58901     } catch (...) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58904       };
58905     }
58906   }
58907
58908   //argout typemap for const std::string&
58909
58910 }
58911
58912
58913 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58914   char * jresult ;
58915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58916   std::string *result = 0 ;
58917
58918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58919   {
58920     try {
58921       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58922     } catch (std::out_of_range& e) {
58923       {
58924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (std::exception& e) {
58927       {
58928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58929       };
58930     } catch (...) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58933       };
58934     }
58935   }
58936   jresult = SWIG_csharp_string_callback(result->c_str());
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58943   Dali::Vector4 *arg2 = 0 ;
58944
58945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58946   arg2 = (Dali::Vector4 *)jarg2;
58947   if (!arg2) {
58948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58949     return ;
58950   }
58951   {
58952     try {
58953       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58954     } catch (std::out_of_range& e) {
58955       {
58956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58957       };
58958     } catch (std::exception& e) {
58959       {
58960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58961       };
58962     } catch (...) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58965       };
58966     }
58967   }
58968 }
58969
58970
58971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58972   void * jresult ;
58973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58974   Dali::Vector4 result;
58975
58976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58977   {
58978     try {
58979       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58980     } catch (std::out_of_range& e) {
58981       {
58982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58983       };
58984     } catch (std::exception& e) {
58985       {
58986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58987       };
58988     } catch (...) {
58989       {
58990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58991       };
58992     }
58993   }
58994   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58995   return jresult;
58996 }
58997
58998
58999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59001   Dali::Image arg2 ;
59002   Dali::Image *argp2 ;
59003
59004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59005   argp2 = (Dali::Image *)jarg2;
59006   if (!argp2) {
59007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59008     return ;
59009   }
59010   arg2 = *argp2;
59011   {
59012     try {
59013       (arg1)->SetBackgroundImage(arg2);
59014     } catch (std::out_of_range& e) {
59015       {
59016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59017       };
59018     } catch (std::exception& e) {
59019       {
59020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59021       };
59022     } catch (...) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59025       };
59026     }
59027   }
59028 }
59029
59030
59031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59033   Dali::Property::Map *arg2 = 0 ;
59034
59035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59036   arg2 = (Dali::Property::Map *)jarg2;
59037   if (!arg2) {
59038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59039     return ;
59040   }
59041   {
59042     try {
59043       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59044     } catch (std::out_of_range& e) {
59045       {
59046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (std::exception& e) {
59049       {
59050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59051       };
59052     } catch (...) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59055       };
59056     }
59057   }
59058 }
59059
59060
59061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59063
59064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59065   {
59066     try {
59067       (arg1)->ClearBackground();
59068     } catch (std::out_of_range& e) {
59069       {
59070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59071       };
59072     } catch (std::exception& e) {
59073       {
59074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59075       };
59076     } catch (...) {
59077       {
59078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59079       };
59080     }
59081   }
59082 }
59083
59084
59085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59087   Dali::Gesture::Type arg2 ;
59088
59089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59090   arg2 = (Dali::Gesture::Type)jarg2;
59091   {
59092     try {
59093       (arg1)->EnableGestureDetection(arg2);
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59101       };
59102     } catch (...) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59105       };
59106     }
59107   }
59108 }
59109
59110
59111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59113   Dali::Gesture::Type arg2 ;
59114
59115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59116   arg2 = (Dali::Gesture::Type)jarg2;
59117   {
59118     try {
59119       (arg1)->DisableGestureDetection(arg2);
59120     } catch (std::out_of_range& e) {
59121       {
59122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59123       };
59124     } catch (std::exception& e) {
59125       {
59126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59127       };
59128     } catch (...) {
59129       {
59130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59131       };
59132     }
59133   }
59134 }
59135
59136
59137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59138   void * jresult ;
59139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59140   Dali::PinchGestureDetector result;
59141
59142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59143   {
59144     try {
59145       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59146     } catch (std::out_of_range& e) {
59147       {
59148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59149       };
59150     } catch (std::exception& e) {
59151       {
59152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59153       };
59154     } catch (...) {
59155       {
59156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59157       };
59158     }
59159   }
59160   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59161   return jresult;
59162 }
59163
59164
59165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59166   void * jresult ;
59167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59168   Dali::PanGestureDetector result;
59169
59170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59171   {
59172     try {
59173       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59174     } catch (std::out_of_range& e) {
59175       {
59176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59177       };
59178     } catch (std::exception& e) {
59179       {
59180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59181       };
59182     } catch (...) {
59183       {
59184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59185       };
59186     }
59187   }
59188   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59189   return jresult;
59190 }
59191
59192
59193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59194   void * jresult ;
59195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59196   Dali::TapGestureDetector result;
59197
59198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59199   {
59200     try {
59201       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59202     } catch (std::out_of_range& e) {
59203       {
59204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59205       };
59206     } catch (std::exception& e) {
59207       {
59208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59209       };
59210     } catch (...) {
59211       {
59212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59213       };
59214     }
59215   }
59216   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59217   return jresult;
59218 }
59219
59220
59221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59222   void * jresult ;
59223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59224   Dali::LongPressGestureDetector result;
59225
59226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59227   {
59228     try {
59229       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59230     } catch (std::out_of_range& e) {
59231       {
59232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59233       };
59234     } catch (std::exception& e) {
59235       {
59236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59237       };
59238     } catch (...) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59241       };
59242     }
59243   }
59244   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59245   return jresult;
59246 }
59247
59248
59249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59251   bool arg2 ;
59252
59253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59254   arg2 = jarg2 ? true : false;
59255   {
59256     try {
59257       (arg1)->SetKeyboardNavigationSupport(arg2);
59258     } catch (std::out_of_range& e) {
59259       {
59260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59261       };
59262     } catch (std::exception& e) {
59263       {
59264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59265       };
59266     } catch (...) {
59267       {
59268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59269       };
59270     }
59271   }
59272 }
59273
59274
59275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59276   unsigned int jresult ;
59277   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59278   bool result;
59279
59280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59281   {
59282     try {
59283       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59284     } catch (std::out_of_range& e) {
59285       {
59286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59287       };
59288     } catch (std::exception& e) {
59289       {
59290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59291       };
59292     } catch (...) {
59293       {
59294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59295       };
59296     }
59297   }
59298   jresult = result;
59299   return jresult;
59300 }
59301
59302
59303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59305
59306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59307   {
59308     try {
59309       (arg1)->SetKeyInputFocus();
59310     } catch (std::out_of_range& e) {
59311       {
59312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59313       };
59314     } catch (std::exception& e) {
59315       {
59316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59317       };
59318     } catch (...) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59321       };
59322     }
59323   }
59324 }
59325
59326
59327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59328   unsigned int jresult ;
59329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59330   bool result;
59331
59332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59333   {
59334     try {
59335       result = (bool)(arg1)->HasKeyInputFocus();
59336     } catch (std::out_of_range& e) {
59337       {
59338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (std::exception& e) {
59341       {
59342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (...) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59347       };
59348     }
59349   }
59350   jresult = result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59357
59358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59359   {
59360     try {
59361       (arg1)->ClearKeyInputFocus();
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59373       };
59374     }
59375   }
59376 }
59377
59378
59379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59381   bool arg2 ;
59382
59383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59384   arg2 = jarg2 ? true : false;
59385   {
59386     try {
59387       (arg1)->SetAsKeyboardFocusGroup(arg2);
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402 }
59403
59404
59405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59406   unsigned int jresult ;
59407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59408   bool result;
59409
59410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59411   {
59412     try {
59413       result = (bool)(arg1)->IsKeyboardFocusGroup();
59414     } catch (std::out_of_range& e) {
59415       {
59416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (std::exception& e) {
59419       {
59420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (...) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59425       };
59426     }
59427   }
59428   jresult = result;
59429   return jresult;
59430 }
59431
59432
59433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59435
59436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59437   {
59438     try {
59439       (arg1)->AccessibilityActivate();
59440     } catch (std::out_of_range& e) {
59441       {
59442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59443       };
59444     } catch (std::exception& e) {
59445       {
59446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59447       };
59448     } catch (...) {
59449       {
59450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59451       };
59452     }
59453   }
59454 }
59455
59456
59457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59459
59460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59461   {
59462     try {
59463       (arg1)->KeyboardEnter();
59464     } catch (std::out_of_range& e) {
59465       {
59466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59467       };
59468     } catch (std::exception& e) {
59469       {
59470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59471       };
59472     } catch (...) {
59473       {
59474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59475       };
59476     }
59477   }
59478 }
59479
59480
59481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59482   void * jresult ;
59483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59484   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59485
59486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59487   {
59488     try {
59489       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59490     } catch (std::out_of_range& e) {
59491       {
59492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59493       };
59494     } catch (std::exception& e) {
59495       {
59496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (...) {
59499       {
59500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59501       };
59502     }
59503   }
59504   jresult = (void *)result;
59505   return jresult;
59506 }
59507
59508
59509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59510   void * jresult ;
59511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59512   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59513
59514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59515   {
59516     try {
59517       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59518     } catch (std::out_of_range& e) {
59519       {
59520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59521       };
59522     } catch (std::exception& e) {
59523       {
59524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59525       };
59526     } catch (...) {
59527       {
59528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59529       };
59530     }
59531   }
59532   jresult = (void *)result;
59533   return jresult;
59534 }
59535
59536
59537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59538   void * jresult ;
59539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59540   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59541
59542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59543   {
59544     try {
59545       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59546     } catch (std::out_of_range& e) {
59547       {
59548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59549       };
59550     } catch (std::exception& e) {
59551       {
59552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (...) {
59555       {
59556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59557       };
59558     }
59559   }
59560   jresult = (void *)result;
59561   return jresult;
59562 }
59563
59564
59565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59566   unsigned int jresult ;
59567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59568   Dali::KeyEvent *arg2 = 0 ;
59569   bool result;
59570
59571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59572   arg2 = (Dali::KeyEvent *)jarg2;
59573   if (!arg2) {
59574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59575     return 0;
59576   }
59577   {
59578     try {
59579       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59580     } catch (std::out_of_range& e) {
59581       {
59582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (std::exception& e) {
59585       {
59586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59587       };
59588     } catch (...) {
59589       {
59590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59591       };
59592     }
59593   }
59594   jresult = result;
59595   return jresult;
59596 }
59597
59598
59599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59601   int arg2 ;
59602   SwigDirector_ViewImpl *darg = 0;
59603
59604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59605   arg2 = (int)jarg2;
59606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59607   {
59608     try {
59609       (darg)->OnStageConnection(arg2);
59610     } catch (std::out_of_range& e) {
59611       {
59612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59613       };
59614     } catch (std::exception& e) {
59615       {
59616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59617       };
59618     } catch (...) {
59619       {
59620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59621       };
59622     }
59623   }
59624 }
59625
59626
59627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59629   int arg2 ;
59630   SwigDirector_ViewImpl *darg = 0;
59631
59632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59633   arg2 = (int)jarg2;
59634   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59635   {
59636     try {
59637       (darg)->OnStageConnectionSwigPublic(arg2);
59638     } catch (std::out_of_range& e) {
59639       {
59640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59641       };
59642     } catch (std::exception& e) {
59643       {
59644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59645       };
59646     } catch (...) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59649       };
59650     }
59651   }
59652 }
59653
59654
59655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59656   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59657   SwigDirector_ViewImpl *darg = 0;
59658
59659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59660   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59661   {
59662     try {
59663       (darg)->OnStageDisconnection();
59664     } catch (std::out_of_range& e) {
59665       {
59666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59667       };
59668     } catch (std::exception& e) {
59669       {
59670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59671       };
59672     } catch (...) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59675       };
59676     }
59677   }
59678 }
59679
59680
59681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59683   SwigDirector_ViewImpl *darg = 0;
59684
59685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59687   {
59688     try {
59689       (darg)->OnStageDisconnectionSwigPublic();
59690     } catch (std::out_of_range& e) {
59691       {
59692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59693       };
59694     } catch (std::exception& e) {
59695       {
59696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59697       };
59698     } catch (...) {
59699       {
59700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59701       };
59702     }
59703   }
59704 }
59705
59706
59707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59709   Dali::Actor *arg2 = 0 ;
59710   SwigDirector_ViewImpl *darg = 0;
59711
59712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59713   arg2 = (Dali::Actor *)jarg2;
59714   if (!arg2) {
59715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59716     return ;
59717   }
59718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59719   {
59720     try {
59721       (darg)->OnChildAdd(*arg2);
59722     } catch (std::out_of_range& e) {
59723       {
59724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59725       };
59726     } catch (std::exception& e) {
59727       {
59728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59729       };
59730     } catch (...) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59733       };
59734     }
59735   }
59736 }
59737
59738
59739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59741   Dali::Actor *arg2 = 0 ;
59742   SwigDirector_ViewImpl *darg = 0;
59743
59744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59745   arg2 = (Dali::Actor *)jarg2;
59746   if (!arg2) {
59747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59748     return ;
59749   }
59750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59751   {
59752     try {
59753       (darg)->OnChildAddSwigPublic(*arg2);
59754     } catch (std::out_of_range& e) {
59755       {
59756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59757       };
59758     } catch (std::exception& e) {
59759       {
59760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59761       };
59762     } catch (...) {
59763       {
59764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59765       };
59766     }
59767   }
59768 }
59769
59770
59771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59773   Dali::Actor *arg2 = 0 ;
59774   SwigDirector_ViewImpl *darg = 0;
59775
59776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59777   arg2 = (Dali::Actor *)jarg2;
59778   if (!arg2) {
59779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59780     return ;
59781   }
59782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59783   {
59784     try {
59785       (darg)->OnChildRemove(*arg2);
59786     } catch (std::out_of_range& e) {
59787       {
59788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59789       };
59790     } catch (std::exception& e) {
59791       {
59792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59793       };
59794     } catch (...) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59797       };
59798     }
59799   }
59800 }
59801
59802
59803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59805   Dali::Actor *arg2 = 0 ;
59806   SwigDirector_ViewImpl *darg = 0;
59807
59808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59809   arg2 = (Dali::Actor *)jarg2;
59810   if (!arg2) {
59811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59812     return ;
59813   }
59814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59815   {
59816     try {
59817       (darg)->OnChildRemoveSwigPublic(*arg2);
59818     } catch (std::out_of_range& e) {
59819       {
59820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59821       };
59822     } catch (std::exception& e) {
59823       {
59824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59825       };
59826     } catch (...) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59829       };
59830     }
59831   }
59832 }
59833
59834
59835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59837   Dali::Property::Index arg2 ;
59838   Dali::Property::Value arg3 ;
59839   Dali::Property::Value *argp3 ;
59840   SwigDirector_ViewImpl *darg = 0;
59841
59842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59843   arg2 = (Dali::Property::Index)jarg2;
59844   argp3 = (Dali::Property::Value *)jarg3;
59845   if (!argp3) {
59846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59847     return ;
59848   }
59849   arg3 = *argp3;
59850   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59851   {
59852     try {
59853       (darg)->OnPropertySet(arg2,arg3);
59854     } catch (std::out_of_range& e) {
59855       {
59856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59857       };
59858     } catch (std::exception& e) {
59859       {
59860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59861       };
59862     } catch (...) {
59863       {
59864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59865       };
59866     }
59867   }
59868 }
59869
59870
59871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59873   Dali::Property::Index arg2 ;
59874   Dali::Property::Value arg3 ;
59875   Dali::Property::Value *argp3 ;
59876   SwigDirector_ViewImpl *darg = 0;
59877
59878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59879   arg2 = (Dali::Property::Index)jarg2;
59880   argp3 = (Dali::Property::Value *)jarg3;
59881   if (!argp3) {
59882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59883     return ;
59884   }
59885   arg3 = *argp3;
59886   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59887   {
59888     try {
59889       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59890     } catch (std::out_of_range& e) {
59891       {
59892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59893       };
59894     } catch (std::exception& e) {
59895       {
59896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59897       };
59898     } catch (...) {
59899       {
59900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59901       };
59902     }
59903   }
59904 }
59905
59906
59907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59908   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59909   Dali::Vector3 *arg2 = 0 ;
59910   SwigDirector_ViewImpl *darg = 0;
59911
59912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59913   arg2 = (Dali::Vector3 *)jarg2;
59914   if (!arg2) {
59915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59916     return ;
59917   }
59918   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59919   {
59920     try {
59921       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59922     } catch (std::out_of_range& e) {
59923       {
59924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59925       };
59926     } catch (std::exception& e) {
59927       {
59928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59929       };
59930     } catch (...) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59933       };
59934     }
59935   }
59936 }
59937
59938
59939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59941   Dali::Vector3 *arg2 = 0 ;
59942   SwigDirector_ViewImpl *darg = 0;
59943
59944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59945   arg2 = (Dali::Vector3 *)jarg2;
59946   if (!arg2) {
59947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59948     return ;
59949   }
59950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59951   {
59952     try {
59953       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59954     } catch (std::out_of_range& e) {
59955       {
59956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59957       };
59958     } catch (std::exception& e) {
59959       {
59960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59961       };
59962     } catch (...) {
59963       {
59964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59965       };
59966     }
59967   }
59968 }
59969
59970
59971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59973   Dali::Animation *arg2 = 0 ;
59974   Dali::Vector3 *arg3 = 0 ;
59975   SwigDirector_ViewImpl *darg = 0;
59976
59977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59978   arg2 = (Dali::Animation *)jarg2;
59979   if (!arg2) {
59980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59981     return ;
59982   }
59983   arg3 = (Dali::Vector3 *)jarg3;
59984   if (!arg3) {
59985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59986     return ;
59987   }
59988   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59989   {
59990     try {
59991       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59992     } catch (std::out_of_range& e) {
59993       {
59994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59995       };
59996     } catch (std::exception& e) {
59997       {
59998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59999       };
60000     } catch (...) {
60001       {
60002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60003       };
60004     }
60005   }
60006 }
60007
60008
60009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60011   Dali::Animation *arg2 = 0 ;
60012   Dali::Vector3 *arg3 = 0 ;
60013   SwigDirector_ViewImpl *darg = 0;
60014
60015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60016   arg2 = (Dali::Animation *)jarg2;
60017   if (!arg2) {
60018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60019     return ;
60020   }
60021   arg3 = (Dali::Vector3 *)jarg3;
60022   if (!arg3) {
60023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60024     return ;
60025   }
60026   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60027   {
60028     try {
60029       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60030     } catch (std::out_of_range& e) {
60031       {
60032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60033       };
60034     } catch (std::exception& e) {
60035       {
60036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60037       };
60038     } catch (...) {
60039       {
60040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60041       };
60042     }
60043   }
60044 }
60045
60046
60047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60048   unsigned int jresult ;
60049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60050   Dali::TouchEvent *arg2 = 0 ;
60051   SwigDirector_ViewImpl *darg = 0;
60052   bool result;
60053
60054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60055   arg2 = (Dali::TouchEvent *)jarg2;
60056   if (!arg2) {
60057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60058     return 0;
60059   }
60060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60061   {
60062     try {
60063       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60064     } catch (std::out_of_range& e) {
60065       {
60066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60067       };
60068     } catch (std::exception& e) {
60069       {
60070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60071       };
60072     } catch (...) {
60073       {
60074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60075       };
60076     }
60077   }
60078   jresult = result;
60079   return jresult;
60080 }
60081
60082
60083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60084   unsigned int jresult ;
60085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60086   Dali::TouchEvent *arg2 = 0 ;
60087   SwigDirector_ViewImpl *darg = 0;
60088   bool result;
60089
60090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60091   arg2 = (Dali::TouchEvent *)jarg2;
60092   if (!arg2) {
60093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60094     return 0;
60095   }
60096   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60097   {
60098     try {
60099       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60100     } catch (std::out_of_range& e) {
60101       {
60102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60103       };
60104     } catch (std::exception& e) {
60105       {
60106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60107       };
60108     } catch (...) {
60109       {
60110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60111       };
60112     }
60113   }
60114   jresult = result;
60115   return jresult;
60116 }
60117
60118
60119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60120   unsigned int jresult ;
60121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60122   Dali::HoverEvent *arg2 = 0 ;
60123   SwigDirector_ViewImpl *darg = 0;
60124   bool result;
60125
60126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60127   arg2 = (Dali::HoverEvent *)jarg2;
60128   if (!arg2) {
60129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60130     return 0;
60131   }
60132   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60133   {
60134     try {
60135       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60136     } catch (std::out_of_range& e) {
60137       {
60138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60139       };
60140     } catch (std::exception& e) {
60141       {
60142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60143       };
60144     } catch (...) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60147       };
60148     }
60149   }
60150   jresult = result;
60151   return jresult;
60152 }
60153
60154
60155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60156   unsigned int jresult ;
60157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60158   Dali::HoverEvent *arg2 = 0 ;
60159   SwigDirector_ViewImpl *darg = 0;
60160   bool result;
60161
60162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60163   arg2 = (Dali::HoverEvent *)jarg2;
60164   if (!arg2) {
60165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60166     return 0;
60167   }
60168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60169   {
60170     try {
60171       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (...) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60183       };
60184     }
60185   }
60186   jresult = result;
60187   return jresult;
60188 }
60189
60190
60191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60192   unsigned int jresult ;
60193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60194   Dali::KeyEvent *arg2 = 0 ;
60195   SwigDirector_ViewImpl *darg = 0;
60196   bool result;
60197
60198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60199   arg2 = (Dali::KeyEvent *)jarg2;
60200   if (!arg2) {
60201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60202     return 0;
60203   }
60204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60205   {
60206     try {
60207       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60208     } catch (std::out_of_range& e) {
60209       {
60210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60211       };
60212     } catch (std::exception& e) {
60213       {
60214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60215       };
60216     } catch (...) {
60217       {
60218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60219       };
60220     }
60221   }
60222   jresult = result;
60223   return jresult;
60224 }
60225
60226
60227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60228   unsigned int jresult ;
60229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60230   Dali::KeyEvent *arg2 = 0 ;
60231   SwigDirector_ViewImpl *darg = 0;
60232   bool result;
60233
60234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60235   arg2 = (Dali::KeyEvent *)jarg2;
60236   if (!arg2) {
60237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60238     return 0;
60239   }
60240   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60241   {
60242     try {
60243       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60244     } catch (std::out_of_range& e) {
60245       {
60246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60247       };
60248     } catch (std::exception& e) {
60249       {
60250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (...) {
60253       {
60254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60255       };
60256     }
60257   }
60258   jresult = result;
60259   return jresult;
60260 }
60261
60262
60263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60264   unsigned int jresult ;
60265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60266   Dali::WheelEvent *arg2 = 0 ;
60267   SwigDirector_ViewImpl *darg = 0;
60268   bool result;
60269
60270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60271   arg2 = (Dali::WheelEvent *)jarg2;
60272   if (!arg2) {
60273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60274     return 0;
60275   }
60276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60277   {
60278     try {
60279       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60280     } catch (std::out_of_range& e) {
60281       {
60282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (std::exception& e) {
60285       {
60286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60287       };
60288     } catch (...) {
60289       {
60290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60291       };
60292     }
60293   }
60294   jresult = result;
60295   return jresult;
60296 }
60297
60298
60299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60300   unsigned int jresult ;
60301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60302   Dali::WheelEvent *arg2 = 0 ;
60303   SwigDirector_ViewImpl *darg = 0;
60304   bool result;
60305
60306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60307   arg2 = (Dali::WheelEvent *)jarg2;
60308   if (!arg2) {
60309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60310     return 0;
60311   }
60312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60313   {
60314     try {
60315       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60316     } catch (std::out_of_range& e) {
60317       {
60318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (std::exception& e) {
60321       {
60322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60323       };
60324     } catch (...) {
60325       {
60326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60327       };
60328     }
60329   }
60330   jresult = result;
60331   return jresult;
60332 }
60333
60334
60335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60337   Dali::Vector2 *arg2 = 0 ;
60338   Dali::RelayoutContainer *arg3 = 0 ;
60339   SwigDirector_ViewImpl *darg = 0;
60340
60341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60342   arg2 = (Dali::Vector2 *)jarg2;
60343   if (!arg2) {
60344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60345     return ;
60346   }
60347   arg3 = (Dali::RelayoutContainer *)jarg3;
60348   if (!arg3) {
60349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60350     return ;
60351   }
60352   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60353   {
60354     try {
60355       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60356     } catch (std::out_of_range& e) {
60357       {
60358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60359       };
60360     } catch (std::exception& e) {
60361       {
60362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60363       };
60364     } catch (...) {
60365       {
60366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60367       };
60368     }
60369   }
60370 }
60371
60372
60373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60375   Dali::Vector2 *arg2 = 0 ;
60376   Dali::RelayoutContainer *arg3 = 0 ;
60377   SwigDirector_ViewImpl *darg = 0;
60378
60379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60380   arg2 = (Dali::Vector2 *)jarg2;
60381   if (!arg2) {
60382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60383     return ;
60384   }
60385   arg3 = (Dali::RelayoutContainer *)jarg3;
60386   if (!arg3) {
60387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60388     return ;
60389   }
60390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60391   {
60392     try {
60393       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60394     } catch (std::out_of_range& e) {
60395       {
60396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60397       };
60398     } catch (std::exception& e) {
60399       {
60400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60401       };
60402     } catch (...) {
60403       {
60404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60405       };
60406     }
60407   }
60408 }
60409
60410
60411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60413   Dali::ResizePolicy::Type arg2 ;
60414   Dali::Dimension::Type arg3 ;
60415   SwigDirector_ViewImpl *darg = 0;
60416
60417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60418   arg2 = (Dali::ResizePolicy::Type)jarg2;
60419   arg3 = (Dali::Dimension::Type)jarg3;
60420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60421   {
60422     try {
60423       (darg)->OnSetResizePolicy(arg2,arg3);
60424     } catch (std::out_of_range& e) {
60425       {
60426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60427       };
60428     } catch (std::exception& e) {
60429       {
60430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60431       };
60432     } catch (...) {
60433       {
60434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60435       };
60436     }
60437   }
60438 }
60439
60440
60441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60443   Dali::ResizePolicy::Type arg2 ;
60444   Dali::Dimension::Type arg3 ;
60445   SwigDirector_ViewImpl *darg = 0;
60446
60447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60448   arg2 = (Dali::ResizePolicy::Type)jarg2;
60449   arg3 = (Dali::Dimension::Type)jarg3;
60450   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60451   {
60452     try {
60453       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60454     } catch (std::out_of_range& e) {
60455       {
60456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60457       };
60458     } catch (std::exception& e) {
60459       {
60460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60461       };
60462     } catch (...) {
60463       {
60464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60465       };
60466     }
60467   }
60468 }
60469
60470
60471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60472   void * jresult ;
60473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60474   SwigDirector_ViewImpl *darg = 0;
60475   Dali::Vector3 result;
60476
60477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60479   {
60480     try {
60481       result = (darg)->GetNaturalSize();
60482     } catch (std::out_of_range& e) {
60483       {
60484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60485       };
60486     } catch (std::exception& e) {
60487       {
60488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60489       };
60490     } catch (...) {
60491       {
60492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60493       };
60494     }
60495   }
60496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60497   return jresult;
60498 }
60499
60500
60501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60502   void * jresult ;
60503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60504   SwigDirector_ViewImpl *darg = 0;
60505   Dali::Vector3 result;
60506
60507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60508   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60509   {
60510     try {
60511       result = (darg)->GetNaturalSizeSwigPublic();
60512     } catch (std::out_of_range& e) {
60513       {
60514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60515       };
60516     } catch (std::exception& e) {
60517       {
60518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (...) {
60521       {
60522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60523       };
60524     }
60525   }
60526   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60527   return jresult;
60528 }
60529
60530
60531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60532   float jresult ;
60533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60534   Dali::Actor *arg2 = 0 ;
60535   Dali::Dimension::Type arg3 ;
60536   SwigDirector_ViewImpl *darg = 0;
60537   float result;
60538
60539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60540   arg2 = (Dali::Actor *)jarg2;
60541   if (!arg2) {
60542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60543     return 0;
60544   }
60545   arg3 = (Dali::Dimension::Type)jarg3;
60546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60547   {
60548     try {
60549       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60550     } catch (std::out_of_range& e) {
60551       {
60552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60553       };
60554     } catch (std::exception& e) {
60555       {
60556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60557       };
60558     } catch (...) {
60559       {
60560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60561       };
60562     }
60563   }
60564   jresult = result;
60565   return jresult;
60566 }
60567
60568
60569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60570   float jresult ;
60571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60572   Dali::Actor *arg2 = 0 ;
60573   Dali::Dimension::Type arg3 ;
60574   SwigDirector_ViewImpl *darg = 0;
60575   float result;
60576
60577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60578   arg2 = (Dali::Actor *)jarg2;
60579   if (!arg2) {
60580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60581     return 0;
60582   }
60583   arg3 = (Dali::Dimension::Type)jarg3;
60584   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60585   {
60586     try {
60587       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60588     } catch (std::out_of_range& e) {
60589       {
60590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (std::exception& e) {
60593       {
60594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (...) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60599       };
60600     }
60601   }
60602   jresult = result;
60603   return jresult;
60604 }
60605
60606
60607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60608   float jresult ;
60609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60610   float arg2 ;
60611   SwigDirector_ViewImpl *darg = 0;
60612   float result;
60613
60614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60615   arg2 = (float)jarg2;
60616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60617   {
60618     try {
60619       result = (float)(darg)->GetHeightForWidth(arg2);
60620     } catch (std::out_of_range& e) {
60621       {
60622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60623       };
60624     } catch (std::exception& e) {
60625       {
60626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60627       };
60628     } catch (...) {
60629       {
60630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60631       };
60632     }
60633   }
60634   jresult = result;
60635   return jresult;
60636 }
60637
60638
60639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60640   float jresult ;
60641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60642   float arg2 ;
60643   SwigDirector_ViewImpl *darg = 0;
60644   float result;
60645
60646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60647   arg2 = (float)jarg2;
60648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60649   {
60650     try {
60651       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60652     } catch (std::out_of_range& e) {
60653       {
60654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (std::exception& e) {
60657       {
60658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (...) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60663       };
60664     }
60665   }
60666   jresult = result;
60667   return jresult;
60668 }
60669
60670
60671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60672   float jresult ;
60673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60674   float arg2 ;
60675   SwigDirector_ViewImpl *darg = 0;
60676   float result;
60677
60678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60679   arg2 = (float)jarg2;
60680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60681   {
60682     try {
60683       result = (float)(darg)->GetWidthForHeight(arg2);
60684     } catch (std::out_of_range& e) {
60685       {
60686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60687       };
60688     } catch (std::exception& e) {
60689       {
60690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60691       };
60692     } catch (...) {
60693       {
60694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60695       };
60696     }
60697   }
60698   jresult = result;
60699   return jresult;
60700 }
60701
60702
60703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60704   float jresult ;
60705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60706   float arg2 ;
60707   SwigDirector_ViewImpl *darg = 0;
60708   float result;
60709
60710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60711   arg2 = (float)jarg2;
60712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60713   {
60714     try {
60715       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60716     } catch (std::out_of_range& e) {
60717       {
60718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (std::exception& e) {
60721       {
60722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60723       };
60724     } catch (...) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60727       };
60728     }
60729   }
60730   jresult = result;
60731   return jresult;
60732 }
60733
60734
60735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60736   unsigned int jresult ;
60737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60738   Dali::Dimension::Type arg2 ;
60739   SwigDirector_ViewImpl *darg = 0;
60740   bool result;
60741
60742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60743   arg2 = (Dali::Dimension::Type)jarg2;
60744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60745   {
60746     try {
60747       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60748     } catch (std::out_of_range& e) {
60749       {
60750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (std::exception& e) {
60753       {
60754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (...) {
60757       {
60758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60759       };
60760     }
60761   }
60762   jresult = result;
60763   return jresult;
60764 }
60765
60766
60767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60768   unsigned int jresult ;
60769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60770   Dali::Dimension::Type arg2 ;
60771   SwigDirector_ViewImpl *darg = 0;
60772   bool result;
60773
60774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60775   arg2 = (Dali::Dimension::Type)jarg2;
60776   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60777   {
60778     try {
60779       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60780     } catch (std::out_of_range& e) {
60781       {
60782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60783       };
60784     } catch (std::exception& e) {
60785       {
60786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60787       };
60788     } catch (...) {
60789       {
60790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60791       };
60792     }
60793   }
60794   jresult = result;
60795   return jresult;
60796 }
60797
60798
60799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60800   unsigned int jresult ;
60801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60802   SwigDirector_ViewImpl *darg = 0;
60803   bool result;
60804
60805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60806   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60807   {
60808     try {
60809       result = (bool)(darg)->RelayoutDependentOnChildren();
60810     } catch (std::out_of_range& e) {
60811       {
60812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60813       };
60814     } catch (std::exception& e) {
60815       {
60816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60817       };
60818     } catch (...) {
60819       {
60820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60821       };
60822     }
60823   }
60824   jresult = result;
60825   return jresult;
60826 }
60827
60828
60829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60830   unsigned int jresult ;
60831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60832   SwigDirector_ViewImpl *darg = 0;
60833   bool result;
60834
60835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60836   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60837   {
60838     try {
60839       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60840     } catch (std::out_of_range& e) {
60841       {
60842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60843       };
60844     } catch (std::exception& e) {
60845       {
60846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60847       };
60848     } catch (...) {
60849       {
60850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60851       };
60852     }
60853   }
60854   jresult = result;
60855   return jresult;
60856 }
60857
60858
60859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60861   Dali::Dimension::Type arg2 ;
60862   SwigDirector_ViewImpl *darg = 0;
60863
60864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60865   arg2 = (Dali::Dimension::Type)jarg2;
60866   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60867   {
60868     try {
60869       (darg)->OnCalculateRelayoutSize(arg2);
60870     } catch (std::out_of_range& e) {
60871       {
60872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60873       };
60874     } catch (std::exception& e) {
60875       {
60876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60877       };
60878     } catch (...) {
60879       {
60880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60881       };
60882     }
60883   }
60884 }
60885
60886
60887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60889   Dali::Dimension::Type arg2 ;
60890   SwigDirector_ViewImpl *darg = 0;
60891
60892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60893   arg2 = (Dali::Dimension::Type)jarg2;
60894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60895   {
60896     try {
60897       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60898     } catch (std::out_of_range& e) {
60899       {
60900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60901       };
60902     } catch (std::exception& e) {
60903       {
60904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60909       };
60910     }
60911   }
60912 }
60913
60914
60915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60917   float arg2 ;
60918   Dali::Dimension::Type arg3 ;
60919   SwigDirector_ViewImpl *darg = 0;
60920
60921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60922   arg2 = (float)jarg2;
60923   arg3 = (Dali::Dimension::Type)jarg3;
60924   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60925   {
60926     try {
60927       (darg)->OnLayoutNegotiated(arg2,arg3);
60928     } catch (std::out_of_range& e) {
60929       {
60930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60931       };
60932     } catch (std::exception& e) {
60933       {
60934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60935       };
60936     } catch (...) {
60937       {
60938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60939       };
60940     }
60941   }
60942 }
60943
60944
60945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60947   float arg2 ;
60948   Dali::Dimension::Type arg3 ;
60949   SwigDirector_ViewImpl *darg = 0;
60950
60951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60952   arg2 = (float)jarg2;
60953   arg3 = (Dali::Dimension::Type)jarg3;
60954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60955   {
60956     try {
60957       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60958     } catch (std::out_of_range& e) {
60959       {
60960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60961       };
60962     } catch (std::exception& e) {
60963       {
60964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60965       };
60966     } catch (...) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60969       };
60970     }
60971   }
60972 }
60973
60974
60975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60977
60978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60979   {
60980     try {
60981       (arg1)->OnInitialize();
60982     } catch (std::out_of_range& e) {
60983       {
60984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60985       };
60986     } catch (std::exception& e) {
60987       {
60988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60989       };
60990     } catch (...) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60993       };
60994     }
60995   }
60996 }
60997
60998
60999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61001
61002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61003   {
61004     try {
61005       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61006     } catch (std::out_of_range& e) {
61007       {
61008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61009       };
61010     } catch (std::exception& e) {
61011       {
61012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61013       };
61014     } catch (...) {
61015       {
61016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61017       };
61018     }
61019   }
61020 }
61021
61022
61023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61025   Dali::Actor *arg2 = 0 ;
61026
61027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61028   arg2 = (Dali::Actor *)jarg2;
61029   if (!arg2) {
61030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61031     return ;
61032   }
61033   {
61034     try {
61035       (arg1)->OnControlChildAdd(*arg2);
61036     } catch (std::out_of_range& e) {
61037       {
61038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61039       };
61040     } catch (std::exception& e) {
61041       {
61042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61043       };
61044     } catch (...) {
61045       {
61046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61047       };
61048     }
61049   }
61050 }
61051
61052
61053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61055   Dali::Actor *arg2 = 0 ;
61056
61057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61058   arg2 = (Dali::Actor *)jarg2;
61059   if (!arg2) {
61060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61061     return ;
61062   }
61063   {
61064     try {
61065       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61066     } catch (std::out_of_range& e) {
61067       {
61068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61069       };
61070     } catch (std::exception& e) {
61071       {
61072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61073       };
61074     } catch (...) {
61075       {
61076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61077       };
61078     }
61079   }
61080 }
61081
61082
61083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61085   Dali::Actor *arg2 = 0 ;
61086
61087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61088   arg2 = (Dali::Actor *)jarg2;
61089   if (!arg2) {
61090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61091     return ;
61092   }
61093   {
61094     try {
61095       (arg1)->OnControlChildRemove(*arg2);
61096     } catch (std::out_of_range& e) {
61097       {
61098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61099       };
61100     } catch (std::exception& e) {
61101       {
61102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61103       };
61104     } catch (...) {
61105       {
61106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61107       };
61108     }
61109   }
61110 }
61111
61112
61113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61115   Dali::Actor *arg2 = 0 ;
61116
61117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61118   arg2 = (Dali::Actor *)jarg2;
61119   if (!arg2) {
61120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61121     return ;
61122   }
61123   {
61124     try {
61125       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61126     } catch (std::out_of_range& e) {
61127       {
61128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61129       };
61130     } catch (std::exception& e) {
61131       {
61132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61133       };
61134     } catch (...) {
61135       {
61136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61137       };
61138     }
61139   }
61140 }
61141
61142
61143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61145   Dali::Toolkit::StyleManager arg2 ;
61146   Dali::StyleChange::Type arg3 ;
61147   Dali::Toolkit::StyleManager *argp2 ;
61148
61149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61150   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61151   if (!argp2) {
61152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61153     return ;
61154   }
61155   arg2 = *argp2;
61156   arg3 = (Dali::StyleChange::Type)jarg3;
61157   {
61158     try {
61159       (arg1)->OnStyleChange(arg2,arg3);
61160     } catch (std::out_of_range& e) {
61161       {
61162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61163       };
61164     } catch (std::exception& e) {
61165       {
61166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61167       };
61168     } catch (...) {
61169       {
61170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61171       };
61172     }
61173   }
61174 }
61175
61176
61177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61179   Dali::Toolkit::StyleManager arg2 ;
61180   Dali::StyleChange::Type arg3 ;
61181   Dali::Toolkit::StyleManager *argp2 ;
61182
61183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61184   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61185   if (!argp2) {
61186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61187     return ;
61188   }
61189   arg2 = *argp2;
61190   arg3 = (Dali::StyleChange::Type)jarg3;
61191   {
61192     try {
61193       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61201       };
61202     } catch (...) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61205       };
61206     }
61207   }
61208 }
61209
61210
61211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61212   unsigned int jresult ;
61213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61214   bool result;
61215
61216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61217   {
61218     try {
61219       result = (bool)(arg1)->OnAccessibilityActivated();
61220     } catch (std::out_of_range& e) {
61221       {
61222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61223       };
61224     } catch (std::exception& e) {
61225       {
61226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61227       };
61228     } catch (...) {
61229       {
61230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61231       };
61232     }
61233   }
61234   jresult = result;
61235   return jresult;
61236 }
61237
61238
61239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61240   unsigned int jresult ;
61241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61242   bool result;
61243
61244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61245   {
61246     try {
61247       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61248     } catch (std::out_of_range& e) {
61249       {
61250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61251       };
61252     } catch (std::exception& e) {
61253       {
61254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61255       };
61256     } catch (...) {
61257       {
61258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61259       };
61260     }
61261   }
61262   jresult = result;
61263   return jresult;
61264 }
61265
61266
61267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61268   unsigned int jresult ;
61269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61270   Dali::PanGesture arg2 ;
61271   Dali::PanGesture *argp2 ;
61272   bool result;
61273
61274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61275   argp2 = (Dali::PanGesture *)jarg2;
61276   if (!argp2) {
61277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61278     return 0;
61279   }
61280   arg2 = *argp2;
61281   {
61282     try {
61283       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61284     } catch (std::out_of_range& e) {
61285       {
61286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (std::exception& e) {
61289       {
61290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61291       };
61292     } catch (...) {
61293       {
61294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61295       };
61296     }
61297   }
61298   jresult = result;
61299   return jresult;
61300 }
61301
61302
61303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61304   unsigned int jresult ;
61305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61306   Dali::PanGesture arg2 ;
61307   Dali::PanGesture *argp2 ;
61308   bool result;
61309
61310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61311   argp2 = (Dali::PanGesture *)jarg2;
61312   if (!argp2) {
61313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61314     return 0;
61315   }
61316   arg2 = *argp2;
61317   {
61318     try {
61319       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61320     } catch (std::out_of_range& e) {
61321       {
61322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61323       };
61324     } catch (std::exception& e) {
61325       {
61326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61327       };
61328     } catch (...) {
61329       {
61330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61331       };
61332     }
61333   }
61334   jresult = result;
61335   return jresult;
61336 }
61337
61338
61339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61340   unsigned int jresult ;
61341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61342   Dali::TouchEvent *arg2 = 0 ;
61343   bool result;
61344
61345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61346   arg2 = (Dali::TouchEvent *)jarg2;
61347   if (!arg2) {
61348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61349     return 0;
61350   }
61351   {
61352     try {
61353       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61354     } catch (std::out_of_range& e) {
61355       {
61356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (std::exception& e) {
61359       {
61360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61361       };
61362     } catch (...) {
61363       {
61364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61365       };
61366     }
61367   }
61368   jresult = result;
61369   return jresult;
61370 }
61371
61372
61373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61374   unsigned int jresult ;
61375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61376   Dali::TouchEvent *arg2 = 0 ;
61377   bool result;
61378
61379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61380   arg2 = (Dali::TouchEvent *)jarg2;
61381   if (!arg2) {
61382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61383     return 0;
61384   }
61385   {
61386     try {
61387       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61399       };
61400     }
61401   }
61402   jresult = result;
61403   return jresult;
61404 }
61405
61406
61407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61408   unsigned int jresult ;
61409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61410   bool arg2 ;
61411   bool result;
61412
61413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61414   arg2 = jarg2 ? true : false;
61415   {
61416     try {
61417       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61418     } catch (std::out_of_range& e) {
61419       {
61420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (std::exception& e) {
61423       {
61424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (...) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61429       };
61430     }
61431   }
61432   jresult = result;
61433   return jresult;
61434 }
61435
61436
61437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61438   unsigned int jresult ;
61439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61440   bool arg2 ;
61441   bool result;
61442
61443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61444   arg2 = jarg2 ? true : false;
61445   {
61446     try {
61447       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61448     } catch (std::out_of_range& e) {
61449       {
61450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61451       };
61452     } catch (std::exception& e) {
61453       {
61454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61455       };
61456     } catch (...) {
61457       {
61458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61459       };
61460     }
61461   }
61462   jresult = result;
61463   return jresult;
61464 }
61465
61466
61467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61468   unsigned int jresult ;
61469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61470   bool result;
61471
61472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61473   {
61474     try {
61475       result = (bool)(arg1)->OnAccessibilityZoom();
61476     } catch (std::out_of_range& e) {
61477       {
61478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61479       };
61480     } catch (std::exception& e) {
61481       {
61482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61483       };
61484     } catch (...) {
61485       {
61486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61487       };
61488     }
61489   }
61490   jresult = result;
61491   return jresult;
61492 }
61493
61494
61495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61496   unsigned int jresult ;
61497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61498   bool result;
61499
61500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61501   {
61502     try {
61503       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61504     } catch (std::out_of_range& e) {
61505       {
61506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61507       };
61508     } catch (std::exception& e) {
61509       {
61510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61511       };
61512     } catch (...) {
61513       {
61514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61515       };
61516     }
61517   }
61518   jresult = result;
61519   return jresult;
61520 }
61521
61522
61523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61525
61526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61527   {
61528     try {
61529       (arg1)->OnKeyInputFocusGained();
61530     } catch (std::out_of_range& e) {
61531       {
61532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61533       };
61534     } catch (std::exception& e) {
61535       {
61536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61537       };
61538     } catch (...) {
61539       {
61540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61541       };
61542     }
61543   }
61544 }
61545
61546
61547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61548   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61549
61550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61551   {
61552     try {
61553       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61554     } catch (std::out_of_range& e) {
61555       {
61556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61557       };
61558     } catch (std::exception& e) {
61559       {
61560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61565       };
61566     }
61567   }
61568 }
61569
61570
61571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61573
61574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61575   {
61576     try {
61577       (arg1)->OnKeyInputFocusLost();
61578     } catch (std::out_of_range& e) {
61579       {
61580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61581       };
61582     } catch (std::exception& e) {
61583       {
61584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61585       };
61586     } catch (...) {
61587       {
61588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61589       };
61590     }
61591   }
61592 }
61593
61594
61595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61597
61598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61599   {
61600     try {
61601       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61602     } catch (std::out_of_range& e) {
61603       {
61604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61605       };
61606     } catch (std::exception& e) {
61607       {
61608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61609       };
61610     } catch (...) {
61611       {
61612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61613       };
61614     }
61615   }
61616 }
61617
61618
61619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61620   void * jresult ;
61621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61622   Dali::Actor arg2 ;
61623   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61624   bool arg4 ;
61625   Dali::Actor *argp2 ;
61626   Dali::Actor result;
61627
61628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61629   argp2 = (Dali::Actor *)jarg2;
61630   if (!argp2) {
61631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61632     return 0;
61633   }
61634   arg2 = *argp2;
61635   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61636   arg4 = jarg4 ? true : false;
61637   {
61638     try {
61639       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61640     } catch (std::out_of_range& e) {
61641       {
61642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61643       };
61644     } catch (std::exception& e) {
61645       {
61646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61647       };
61648     } catch (...) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61651       };
61652     }
61653   }
61654   jresult = new Dali::Actor((const Dali::Actor &)result);
61655   return jresult;
61656 }
61657
61658
61659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61660   void * jresult ;
61661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61662   Dali::Actor arg2 ;
61663   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61664   bool arg4 ;
61665   Dali::Actor *argp2 ;
61666   Dali::Actor result;
61667
61668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61669   argp2 = (Dali::Actor *)jarg2;
61670   if (!argp2) {
61671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61672     return 0;
61673   }
61674   arg2 = *argp2;
61675   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61676   arg4 = jarg4 ? true : false;
61677   {
61678     try {
61679       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61680     } catch (std::out_of_range& e) {
61681       {
61682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61683       };
61684     } catch (std::exception& e) {
61685       {
61686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61687       };
61688     } catch (...) {
61689       {
61690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61691       };
61692     }
61693   }
61694   jresult = new Dali::Actor((const Dali::Actor &)result);
61695   return jresult;
61696 }
61697
61698
61699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61701   Dali::Actor arg2 ;
61702   Dali::Actor *argp2 ;
61703
61704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61705   argp2 = (Dali::Actor *)jarg2;
61706   if (!argp2) {
61707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61708     return ;
61709   }
61710   arg2 = *argp2;
61711   {
61712     try {
61713       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61714     } catch (std::out_of_range& e) {
61715       {
61716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61717       };
61718     } catch (std::exception& e) {
61719       {
61720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61721       };
61722     } catch (...) {
61723       {
61724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61725       };
61726     }
61727   }
61728 }
61729
61730
61731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61733   Dali::Actor arg2 ;
61734   Dali::Actor *argp2 ;
61735
61736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61737   argp2 = (Dali::Actor *)jarg2;
61738   if (!argp2) {
61739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61740     return ;
61741   }
61742   arg2 = *argp2;
61743   {
61744     try {
61745       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61746     } catch (std::out_of_range& e) {
61747       {
61748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61749       };
61750     } catch (std::exception& e) {
61751       {
61752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61753       };
61754     } catch (...) {
61755       {
61756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61757       };
61758     }
61759   }
61760 }
61761
61762
61763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61764   unsigned int jresult ;
61765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61766   bool result;
61767
61768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61769   {
61770     try {
61771       result = (bool)(arg1)->OnKeyboardEnter();
61772     } catch (std::out_of_range& e) {
61773       {
61774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61775       };
61776     } catch (std::exception& e) {
61777       {
61778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61779       };
61780     } catch (...) {
61781       {
61782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61783       };
61784     }
61785   }
61786   jresult = result;
61787   return jresult;
61788 }
61789
61790
61791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61792   unsigned int jresult ;
61793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61794   bool result;
61795
61796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61797   {
61798     try {
61799       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61800     } catch (std::out_of_range& e) {
61801       {
61802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (std::exception& e) {
61805       {
61806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61807       };
61808     } catch (...) {
61809       {
61810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61811       };
61812     }
61813   }
61814   jresult = result;
61815   return jresult;
61816 }
61817
61818
61819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61821   Dali::PinchGesture *arg2 = 0 ;
61822
61823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61824   arg2 = (Dali::PinchGesture *)jarg2;
61825   if (!arg2) {
61826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61827     return ;
61828   }
61829   {
61830     try {
61831       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61832     } catch (std::out_of_range& e) {
61833       {
61834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61835       };
61836     } catch (std::exception& e) {
61837       {
61838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61839       };
61840     } catch (...) {
61841       {
61842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61843       };
61844     }
61845   }
61846 }
61847
61848
61849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61851   Dali::PinchGesture *arg2 = 0 ;
61852
61853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61854   arg2 = (Dali::PinchGesture *)jarg2;
61855   if (!arg2) {
61856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61857     return ;
61858   }
61859   {
61860     try {
61861       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61862     } catch (std::out_of_range& e) {
61863       {
61864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61865       };
61866     } catch (std::exception& e) {
61867       {
61868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61869       };
61870     } catch (...) {
61871       {
61872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61873       };
61874     }
61875   }
61876 }
61877
61878
61879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61881   Dali::PanGesture *arg2 = 0 ;
61882
61883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61884   arg2 = (Dali::PanGesture *)jarg2;
61885   if (!arg2) {
61886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61887     return ;
61888   }
61889   {
61890     try {
61891       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61892     } catch (std::out_of_range& e) {
61893       {
61894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61895       };
61896     } catch (std::exception& e) {
61897       {
61898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61899       };
61900     } catch (...) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61903       };
61904     }
61905   }
61906 }
61907
61908
61909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61911   Dali::PanGesture *arg2 = 0 ;
61912
61913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61914   arg2 = (Dali::PanGesture *)jarg2;
61915   if (!arg2) {
61916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61917     return ;
61918   }
61919   {
61920     try {
61921       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61922     } catch (std::out_of_range& e) {
61923       {
61924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61925       };
61926     } catch (std::exception& e) {
61927       {
61928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61929       };
61930     } catch (...) {
61931       {
61932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61933       };
61934     }
61935   }
61936 }
61937
61938
61939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61941   Dali::TapGesture *arg2 = 0 ;
61942
61943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61944   arg2 = (Dali::TapGesture *)jarg2;
61945   if (!arg2) {
61946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61947     return ;
61948   }
61949   {
61950     try {
61951       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61952     } catch (std::out_of_range& e) {
61953       {
61954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61955       };
61956     } catch (std::exception& e) {
61957       {
61958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61959       };
61960     } catch (...) {
61961       {
61962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61963       };
61964     }
61965   }
61966 }
61967
61968
61969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61971   Dali::TapGesture *arg2 = 0 ;
61972
61973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61974   arg2 = (Dali::TapGesture *)jarg2;
61975   if (!arg2) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61977     return ;
61978   }
61979   {
61980     try {
61981       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61982     } catch (std::out_of_range& e) {
61983       {
61984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61985       };
61986     } catch (std::exception& e) {
61987       {
61988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61989       };
61990     } catch (...) {
61991       {
61992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61993       };
61994     }
61995   }
61996 }
61997
61998
61999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62001   Dali::LongPressGesture *arg2 = 0 ;
62002
62003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62004   arg2 = (Dali::LongPressGesture *)jarg2;
62005   if (!arg2) {
62006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62007     return ;
62008   }
62009   {
62010     try {
62011       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62012     } catch (std::out_of_range& e) {
62013       {
62014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62015       };
62016     } catch (std::exception& e) {
62017       {
62018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62019       };
62020     } catch (...) {
62021       {
62022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62023       };
62024     }
62025   }
62026 }
62027
62028
62029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62031   Dali::LongPressGesture *arg2 = 0 ;
62032
62033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62034   arg2 = (Dali::LongPressGesture *)jarg2;
62035   if (!arg2) {
62036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62037     return ;
62038   }
62039   {
62040     try {
62041       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62042     } catch (std::out_of_range& e) {
62043       {
62044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62045       };
62046     } catch (std::exception& e) {
62047       {
62048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62049       };
62050     } catch (...) {
62051       {
62052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62053       };
62054     }
62055   }
62056 }
62057
62058
62059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62061   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62062   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62063
62064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62065   arg2 = (Dali::SlotObserver *)jarg2;
62066   arg3 = (Dali::CallbackBase *)jarg3;
62067   {
62068     try {
62069       (arg1)->SignalConnected(arg2,arg3);
62070     } catch (std::out_of_range& e) {
62071       {
62072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62073       };
62074     } catch (std::exception& e) {
62075       {
62076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62077       };
62078     } catch (...) {
62079       {
62080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62081       };
62082     }
62083   }
62084 }
62085
62086
62087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62089   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62090   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62091
62092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62093   arg2 = (Dali::SlotObserver *)jarg2;
62094   arg3 = (Dali::CallbackBase *)jarg3;
62095   {
62096     try {
62097       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62109       };
62110     }
62111   }
62112 }
62113
62114
62115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62117   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62118   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62119
62120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62121   arg2 = (Dali::SlotObserver *)jarg2;
62122   arg3 = (Dali::CallbackBase *)jarg3;
62123   {
62124     try {
62125       (arg1)->SignalDisconnected(arg2,arg3);
62126     } catch (std::out_of_range& e) {
62127       {
62128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62129       };
62130     } catch (std::exception& e) {
62131       {
62132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62133       };
62134     } catch (...) {
62135       {
62136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62137       };
62138     }
62139   }
62140 }
62141
62142
62143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62145   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62146   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62147
62148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62149   arg2 = (Dali::SlotObserver *)jarg2;
62150   arg3 = (Dali::CallbackBase *)jarg3;
62151   {
62152     try {
62153       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62154     } catch (std::out_of_range& e) {
62155       {
62156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62157       };
62158     } catch (std::exception& e) {
62159       {
62160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62161       };
62162     } catch (...) {
62163       {
62164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62165       };
62166     }
62167   }
62168 }
62169
62170
62171 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) {
62172   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62173   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62174   if (director) {
62175     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);
62176   }
62177 }
62178
62179
62180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62181   void * jresult ;
62182   Dali::Toolkit::Control *arg1 = 0 ;
62183   Dali::Toolkit::Internal::Control *result = 0 ;
62184
62185   arg1 = (Dali::Toolkit::Control *)jarg1;
62186   if (!arg1) {
62187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62188     return 0;
62189   }
62190   {
62191     try {
62192       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62204       };
62205     }
62206   }
62207   jresult = (void *)result;
62208   return jresult;
62209 }
62210
62211
62212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62213   int jresult ;
62214   int result;
62215
62216   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62217   jresult = (int)result;
62218   return jresult;
62219 }
62220
62221
62222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62223   int jresult ;
62224   int result;
62225
62226   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62227   jresult = (int)result;
62228   return jresult;
62229 }
62230
62231
62232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62233   int jresult ;
62234   int result;
62235
62236   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62237   jresult = (int)result;
62238   return jresult;
62239 }
62240
62241
62242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62243   int jresult ;
62244   int result;
62245
62246   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62247   jresult = (int)result;
62248   return jresult;
62249 }
62250
62251
62252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62253   int jresult ;
62254   int result;
62255
62256   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62257   jresult = (int)result;
62258   return jresult;
62259 }
62260
62261
62262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62263   void * jresult ;
62264   Dali::Toolkit::Control::Property *result = 0 ;
62265
62266   {
62267     try {
62268       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62269     } catch (std::out_of_range& e) {
62270       {
62271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (std::exception& e) {
62274       {
62275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283   jresult = (void *)result;
62284   return jresult;
62285 }
62286
62287
62288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62289   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62290
62291   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62292   {
62293     try {
62294       delete arg1;
62295     } catch (std::out_of_range& e) {
62296       {
62297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62298       };
62299     } catch (std::exception& e) {
62300       {
62301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62302       };
62303     } catch (...) {
62304       {
62305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62306       };
62307     }
62308   }
62309 }
62310
62311
62312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62313   void * jresult ;
62314   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62315
62316   {
62317     try {
62318       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62319     } catch (std::out_of_range& e) {
62320       {
62321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62322       };
62323     } catch (std::exception& e) {
62324       {
62325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62326       };
62327     } catch (...) {
62328       {
62329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62330       };
62331     }
62332   }
62333   jresult = (void *)result;
62334   return jresult;
62335 }
62336
62337
62338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62339   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62340
62341   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62342   {
62343     try {
62344       delete arg1;
62345     } catch (std::out_of_range& e) {
62346       {
62347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62348       };
62349     } catch (std::exception& e) {
62350       {
62351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62352       };
62353     } catch (...) {
62354       {
62355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62356       };
62357     }
62358   }
62359 }
62360
62361
62362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62363   void * jresult ;
62364   Dali::Toolkit::Control result;
62365
62366   {
62367     try {
62368       result = Dali::Toolkit::Control::New();
62369     } catch (std::out_of_range& e) {
62370       {
62371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62372       };
62373     } catch (std::exception& e) {
62374       {
62375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62376       };
62377     } catch (...) {
62378       {
62379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62380       };
62381     }
62382   }
62383   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62384   return jresult;
62385 }
62386
62387
62388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62389   void * jresult ;
62390   Dali::Toolkit::Control *result = 0 ;
62391
62392   {
62393     try {
62394       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62395     } catch (std::out_of_range& e) {
62396       {
62397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (std::exception& e) {
62400       {
62401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62402       };
62403     } catch (...) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62406       };
62407     }
62408   }
62409   jresult = (void *)result;
62410   return jresult;
62411 }
62412
62413
62414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62415   void * jresult ;
62416   Dali::Toolkit::Control *arg1 = 0 ;
62417   Dali::Toolkit::Control *result = 0 ;
62418
62419   arg1 = (Dali::Toolkit::Control *)jarg1;
62420   if (!arg1) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62422     return 0;
62423   }
62424   {
62425     try {
62426       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62427     } catch (std::out_of_range& e) {
62428       {
62429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (std::exception& e) {
62432       {
62433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (...) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62438       };
62439     }
62440   }
62441   jresult = (void *)result;
62442   return jresult;
62443 }
62444
62445
62446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62447   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62448
62449   arg1 = (Dali::Toolkit::Control *)jarg1;
62450   {
62451     try {
62452       delete arg1;
62453     } catch (std::out_of_range& e) {
62454       {
62455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62456       };
62457     } catch (std::exception& e) {
62458       {
62459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62460       };
62461     } catch (...) {
62462       {
62463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62464       };
62465     }
62466   }
62467 }
62468
62469
62470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62471   void * jresult ;
62472   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62473   Dali::Toolkit::Control *arg2 = 0 ;
62474   Dali::Toolkit::Control *result = 0 ;
62475
62476   arg1 = (Dali::Toolkit::Control *)jarg1;
62477   arg2 = (Dali::Toolkit::Control *)jarg2;
62478   if (!arg2) {
62479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62480     return 0;
62481   }
62482   {
62483     try {
62484       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62485     } catch (std::out_of_range& e) {
62486       {
62487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62488       };
62489     } catch (std::exception& e) {
62490       {
62491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62492       };
62493     } catch (...) {
62494       {
62495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62496       };
62497     }
62498   }
62499   jresult = (void *)result;
62500   return jresult;
62501 }
62502
62503
62504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62505   void * jresult ;
62506   Dali::BaseHandle arg1 ;
62507   Dali::BaseHandle *argp1 ;
62508   Dali::Toolkit::Control result;
62509
62510   argp1 = (Dali::BaseHandle *)jarg1;
62511   if (!argp1) {
62512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62513     return 0;
62514   }
62515   arg1 = *argp1;
62516   {
62517     try {
62518       result = Dali::Toolkit::Control::DownCast(arg1);
62519     } catch (std::out_of_range& e) {
62520       {
62521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62522       };
62523     } catch (std::exception& e) {
62524       {
62525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62526       };
62527     } catch (...) {
62528       {
62529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62530       };
62531     }
62532   }
62533   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62534   return jresult;
62535 }
62536
62537
62538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62539   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62540
62541   arg1 = (Dali::Toolkit::Control *)jarg1;
62542   {
62543     try {
62544       (arg1)->SetKeyInputFocus();
62545     } catch (std::out_of_range& e) {
62546       {
62547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62548       };
62549     } catch (std::exception& e) {
62550       {
62551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62552       };
62553     } catch (...) {
62554       {
62555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62556       };
62557     }
62558   }
62559 }
62560
62561
62562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62563   unsigned int jresult ;
62564   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62565   bool result;
62566
62567   arg1 = (Dali::Toolkit::Control *)jarg1;
62568   {
62569     try {
62570       result = (bool)(arg1)->HasKeyInputFocus();
62571     } catch (std::out_of_range& e) {
62572       {
62573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62574       };
62575     } catch (std::exception& e) {
62576       {
62577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (...) {
62580       {
62581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62582       };
62583     }
62584   }
62585   jresult = result;
62586   return jresult;
62587 }
62588
62589
62590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62592
62593   arg1 = (Dali::Toolkit::Control *)jarg1;
62594   {
62595     try {
62596       (arg1)->ClearKeyInputFocus();
62597     } catch (std::out_of_range& e) {
62598       {
62599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62600       };
62601     } catch (std::exception& e) {
62602       {
62603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62604       };
62605     } catch (...) {
62606       {
62607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62608       };
62609     }
62610   }
62611 }
62612
62613
62614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62615   void * jresult ;
62616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62617   Dali::PinchGestureDetector result;
62618
62619   arg1 = (Dali::Toolkit::Control *)jarg1;
62620   {
62621     try {
62622       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62623     } catch (std::out_of_range& e) {
62624       {
62625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62626       };
62627     } catch (std::exception& e) {
62628       {
62629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62630       };
62631     } catch (...) {
62632       {
62633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62634       };
62635     }
62636   }
62637   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62643   void * jresult ;
62644   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62645   Dali::PanGestureDetector result;
62646
62647   arg1 = (Dali::Toolkit::Control *)jarg1;
62648   {
62649     try {
62650       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62658       };
62659     } catch (...) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62662       };
62663     }
62664   }
62665   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62666   return jresult;
62667 }
62668
62669
62670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62671   void * jresult ;
62672   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62673   Dali::TapGestureDetector result;
62674
62675   arg1 = (Dali::Toolkit::Control *)jarg1;
62676   {
62677     try {
62678       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62679     } catch (std::out_of_range& e) {
62680       {
62681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62682       };
62683     } catch (std::exception& e) {
62684       {
62685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62686       };
62687     } catch (...) {
62688       {
62689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62690       };
62691     }
62692   }
62693   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62694   return jresult;
62695 }
62696
62697
62698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62699   void * jresult ;
62700   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62701   Dali::LongPressGestureDetector result;
62702
62703   arg1 = (Dali::Toolkit::Control *)jarg1;
62704   {
62705     try {
62706       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62707     } catch (std::out_of_range& e) {
62708       {
62709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62710       };
62711     } catch (std::exception& e) {
62712       {
62713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62714       };
62715     } catch (...) {
62716       {
62717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62718       };
62719     }
62720   }
62721   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62722   return jresult;
62723 }
62724
62725
62726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62727   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62728   std::string *arg2 = 0 ;
62729
62730   arg1 = (Dali::Toolkit::Control *)jarg1;
62731   if (!jarg2) {
62732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62733     return ;
62734   }
62735   std::string arg2_str(jarg2);
62736   arg2 = &arg2_str;
62737   {
62738     try {
62739       (arg1)->SetStyleName((std::string const &)*arg2);
62740     } catch (std::out_of_range& e) {
62741       {
62742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62743       };
62744     } catch (std::exception& e) {
62745       {
62746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62747       };
62748     } catch (...) {
62749       {
62750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62751       };
62752     }
62753   }
62754
62755   //argout typemap for const std::string&
62756
62757 }
62758
62759
62760 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62761   char * jresult ;
62762   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62763   std::string *result = 0 ;
62764
62765   arg1 = (Dali::Toolkit::Control *)jarg1;
62766   {
62767     try {
62768       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62769     } catch (std::out_of_range& e) {
62770       {
62771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (std::exception& e) {
62774       {
62775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62776       };
62777     } catch (...) {
62778       {
62779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62780       };
62781     }
62782   }
62783   jresult = SWIG_csharp_string_callback(result->c_str());
62784   return jresult;
62785 }
62786
62787
62788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62789   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62790   Dali::Vector4 *arg2 = 0 ;
62791
62792   arg1 = (Dali::Toolkit::Control *)jarg1;
62793   arg2 = (Dali::Vector4 *)jarg2;
62794   if (!arg2) {
62795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62796     return ;
62797   }
62798   {
62799     try {
62800       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62801     } catch (std::out_of_range& e) {
62802       {
62803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62804       };
62805     } catch (std::exception& e) {
62806       {
62807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62808       };
62809     } catch (...) {
62810       {
62811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62812       };
62813     }
62814   }
62815 }
62816
62817
62818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62819   void * jresult ;
62820   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62821   Dali::Vector4 result;
62822
62823   arg1 = (Dali::Toolkit::Control *)jarg1;
62824   {
62825     try {
62826       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62838       };
62839     }
62840   }
62841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62842   return jresult;
62843 }
62844
62845
62846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62847   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62848   Dali::Image arg2 ;
62849   Dali::Image *argp2 ;
62850
62851   arg1 = (Dali::Toolkit::Control *)jarg1;
62852   argp2 = (Dali::Image *)jarg2;
62853   if (!argp2) {
62854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62855     return ;
62856   }
62857   arg2 = *argp2;
62858   {
62859     try {
62860       (arg1)->SetBackgroundImage(arg2);
62861     } catch (std::out_of_range& e) {
62862       {
62863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62864       };
62865     } catch (std::exception& e) {
62866       {
62867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62868       };
62869     } catch (...) {
62870       {
62871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62872       };
62873     }
62874   }
62875 }
62876
62877
62878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62879   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62880
62881   arg1 = (Dali::Toolkit::Control *)jarg1;
62882   {
62883     try {
62884       (arg1)->ClearBackground();
62885     } catch (std::out_of_range& e) {
62886       {
62887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62888       };
62889     } catch (std::exception& e) {
62890       {
62891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62892       };
62893     } catch (...) {
62894       {
62895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62896       };
62897     }
62898   }
62899 }
62900
62901
62902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62903   void * jresult ;
62904   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62905   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62906
62907   arg1 = (Dali::Toolkit::Control *)jarg1;
62908   {
62909     try {
62910       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62911     } catch (std::out_of_range& e) {
62912       {
62913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62914       };
62915     } catch (std::exception& e) {
62916       {
62917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (...) {
62920       {
62921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62922       };
62923     }
62924   }
62925   jresult = (void *)result;
62926   return jresult;
62927 }
62928
62929
62930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62931   void * jresult ;
62932   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62933   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62934
62935   arg1 = (Dali::Toolkit::Control *)jarg1;
62936   {
62937     try {
62938       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62939     } catch (std::out_of_range& e) {
62940       {
62941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (std::exception& e) {
62944       {
62945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62950       };
62951     }
62952   }
62953   jresult = (void *)result;
62954   return jresult;
62955 }
62956
62957
62958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62959   void * jresult ;
62960   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62961   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62962
62963   arg1 = (Dali::Toolkit::Control *)jarg1;
62964   {
62965     try {
62966       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (...) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62978       };
62979     }
62980   }
62981   jresult = (void *)result;
62982   return jresult;
62983 }
62984
62985
62986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62987   void * jresult ;
62988   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62989   Dali::Toolkit::Control *result = 0 ;
62990
62991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62992   if (!arg1) {
62993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
62994     return 0;
62995   }
62996   {
62997     try {
62998       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
62999     } catch (std::out_of_range& e) {
63000       {
63001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (std::exception& e) {
63004       {
63005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (...) {
63008       {
63009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63010       };
63011     }
63012   }
63013   jresult = (void *)result;
63014   return jresult;
63015 }
63016
63017
63018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63019   void * jresult ;
63020   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63021
63022   {
63023     try {
63024       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63025     } catch (std::out_of_range& e) {
63026       {
63027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63028       };
63029     } catch (std::exception& e) {
63030       {
63031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63032       };
63033     } catch (...) {
63034       {
63035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63036       };
63037     }
63038   }
63039   jresult = (void *)result;
63040   return jresult;
63041 }
63042
63043
63044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63045   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63046
63047   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63048   {
63049     try {
63050       delete arg1;
63051     } catch (std::out_of_range& e) {
63052       {
63053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63054       };
63055     } catch (std::exception& e) {
63056       {
63057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63058       };
63059     } catch (...) {
63060       {
63061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63062       };
63063     }
63064   }
63065 }
63066
63067
63068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63069   void * jresult ;
63070   Dali::Toolkit::KeyInputFocusManager result;
63071
63072   {
63073     try {
63074       result = Dali::Toolkit::KeyInputFocusManager::Get();
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (...) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63086       };
63087     }
63088   }
63089   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63090   return jresult;
63091 }
63092
63093
63094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63095   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63096   Dali::Toolkit::Control arg2 ;
63097   Dali::Toolkit::Control *argp2 ;
63098
63099   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63100   argp2 = (Dali::Toolkit::Control *)jarg2;
63101   if (!argp2) {
63102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63103     return ;
63104   }
63105   arg2 = *argp2;
63106   {
63107     try {
63108       (arg1)->SetFocus(arg2);
63109     } catch (std::out_of_range& e) {
63110       {
63111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63112       };
63113     } catch (std::exception& e) {
63114       {
63115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63120       };
63121     }
63122   }
63123 }
63124
63125
63126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63127   void * jresult ;
63128   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63129   Dali::Toolkit::Control result;
63130
63131   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63132   {
63133     try {
63134       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63135     } catch (std::out_of_range& e) {
63136       {
63137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63138       };
63139     } catch (std::exception& e) {
63140       {
63141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (...) {
63144       {
63145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63146       };
63147     }
63148   }
63149   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63150   return jresult;
63151 }
63152
63153
63154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63155   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63156   Dali::Toolkit::Control arg2 ;
63157   Dali::Toolkit::Control *argp2 ;
63158
63159   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63160   argp2 = (Dali::Toolkit::Control *)jarg2;
63161   if (!argp2) {
63162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63163     return ;
63164   }
63165   arg2 = *argp2;
63166   {
63167     try {
63168       (arg1)->RemoveFocus(arg2);
63169     } catch (std::out_of_range& e) {
63170       {
63171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63172       };
63173     } catch (std::exception& e) {
63174       {
63175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63176       };
63177     } catch (...) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63180       };
63181     }
63182   }
63183 }
63184
63185
63186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63187   void * jresult ;
63188   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63189   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63190
63191   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63192   {
63193     try {
63194       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63195     } catch (std::out_of_range& e) {
63196       {
63197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63198       };
63199     } catch (std::exception& e) {
63200       {
63201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63202       };
63203     } catch (...) {
63204       {
63205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63206       };
63207     }
63208   }
63209   jresult = (void *)result;
63210   return jresult;
63211 }
63212
63213
63214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63215   void * jresult ;
63216   Dali::Toolkit::Alignment::Padding *result = 0 ;
63217
63218   {
63219     try {
63220       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63221     } catch (std::out_of_range& e) {
63222       {
63223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63224       };
63225     } catch (std::exception& e) {
63226       {
63227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63232       };
63233     }
63234   }
63235   jresult = (void *)result;
63236   return jresult;
63237 }
63238
63239
63240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63241   void * jresult ;
63242   float arg1 ;
63243   float arg2 ;
63244   float arg3 ;
63245   float arg4 ;
63246   Dali::Toolkit::Alignment::Padding *result = 0 ;
63247
63248   arg1 = (float)jarg1;
63249   arg2 = (float)jarg2;
63250   arg3 = (float)jarg3;
63251   arg4 = (float)jarg4;
63252   {
63253     try {
63254       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63255     } catch (std::out_of_range& e) {
63256       {
63257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63258       };
63259     } catch (std::exception& e) {
63260       {
63261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63262       };
63263     } catch (...) {
63264       {
63265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63266       };
63267     }
63268   }
63269   jresult = (void *)result;
63270   return jresult;
63271 }
63272
63273
63274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63275   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63276   float arg2 ;
63277
63278   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63279   arg2 = (float)jarg2;
63280   if (arg1) (arg1)->left = arg2;
63281 }
63282
63283
63284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63285   float jresult ;
63286   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63287   float result;
63288
63289   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63290   result = (float) ((arg1)->left);
63291   jresult = result;
63292   return jresult;
63293 }
63294
63295
63296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63297   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63298   float arg2 ;
63299
63300   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63301   arg2 = (float)jarg2;
63302   if (arg1) (arg1)->right = arg2;
63303 }
63304
63305
63306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63307   float jresult ;
63308   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63309   float result;
63310
63311   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63312   result = (float) ((arg1)->right);
63313   jresult = result;
63314   return jresult;
63315 }
63316
63317
63318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63319   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63320   float arg2 ;
63321
63322   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63323   arg2 = (float)jarg2;
63324   if (arg1) (arg1)->top = arg2;
63325 }
63326
63327
63328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63329   float jresult ;
63330   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63331   float result;
63332
63333   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63334   result = (float) ((arg1)->top);
63335   jresult = result;
63336   return jresult;
63337 }
63338
63339
63340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63341   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63342   float arg2 ;
63343
63344   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63345   arg2 = (float)jarg2;
63346   if (arg1) (arg1)->bottom = arg2;
63347 }
63348
63349
63350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63351   float jresult ;
63352   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63353   float result;
63354
63355   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63356   result = (float) ((arg1)->bottom);
63357   jresult = result;
63358   return jresult;
63359 }
63360
63361
63362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63363   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63364
63365   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63366   {
63367     try {
63368       delete arg1;
63369     } catch (std::out_of_range& e) {
63370       {
63371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63372       };
63373     } catch (std::exception& e) {
63374       {
63375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63376       };
63377     } catch (...) {
63378       {
63379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63380       };
63381     }
63382   }
63383 }
63384
63385
63386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63387   void * jresult ;
63388   Dali::Toolkit::Alignment *result = 0 ;
63389
63390   {
63391     try {
63392       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63393     } catch (std::out_of_range& e) {
63394       {
63395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63396       };
63397     } catch (std::exception& e) {
63398       {
63399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63400       };
63401     } catch (...) {
63402       {
63403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63404       };
63405     }
63406   }
63407   jresult = (void *)result;
63408   return jresult;
63409 }
63410
63411
63412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63413   void * jresult ;
63414   Dali::Toolkit::Alignment::Type arg1 ;
63415   Dali::Toolkit::Alignment::Type arg2 ;
63416   Dali::Toolkit::Alignment result;
63417
63418   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63419   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63420   {
63421     try {
63422       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63423     } catch (std::out_of_range& e) {
63424       {
63425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63426       };
63427     } catch (std::exception& e) {
63428       {
63429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63430       };
63431     } catch (...) {
63432       {
63433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63434       };
63435     }
63436   }
63437   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63438   return jresult;
63439 }
63440
63441
63442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63443   void * jresult ;
63444   Dali::Toolkit::Alignment::Type arg1 ;
63445   Dali::Toolkit::Alignment result;
63446
63447   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63448   {
63449     try {
63450       result = Dali::Toolkit::Alignment::New(arg1);
63451     } catch (std::out_of_range& e) {
63452       {
63453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63454       };
63455     } catch (std::exception& e) {
63456       {
63457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63458       };
63459     } catch (...) {
63460       {
63461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63462       };
63463     }
63464   }
63465   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63466   return jresult;
63467 }
63468
63469
63470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63471   void * jresult ;
63472   Dali::Toolkit::Alignment result;
63473
63474   {
63475     try {
63476       result = Dali::Toolkit::Alignment::New();
63477     } catch (std::out_of_range& e) {
63478       {
63479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63480       };
63481     } catch (std::exception& e) {
63482       {
63483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63484       };
63485     } catch (...) {
63486       {
63487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63488       };
63489     }
63490   }
63491   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63492   return jresult;
63493 }
63494
63495
63496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63497   void * jresult ;
63498   Dali::Toolkit::Alignment *arg1 = 0 ;
63499   Dali::Toolkit::Alignment *result = 0 ;
63500
63501   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63502   if (!arg1) {
63503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63504     return 0;
63505   }
63506   {
63507     try {
63508       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63509     } catch (std::out_of_range& e) {
63510       {
63511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63512       };
63513     } catch (std::exception& e) {
63514       {
63515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63520       };
63521     }
63522   }
63523   jresult = (void *)result;
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63529   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63530
63531   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63532   {
63533     try {
63534       delete arg1;
63535     } catch (std::out_of_range& e) {
63536       {
63537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63538       };
63539     } catch (std::exception& e) {
63540       {
63541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63542       };
63543     } catch (...) {
63544       {
63545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63546       };
63547     }
63548   }
63549 }
63550
63551
63552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63553   void * jresult ;
63554   Dali::BaseHandle arg1 ;
63555   Dali::BaseHandle *argp1 ;
63556   Dali::Toolkit::Alignment result;
63557
63558   argp1 = (Dali::BaseHandle *)jarg1;
63559   if (!argp1) {
63560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63561     return 0;
63562   }
63563   arg1 = *argp1;
63564   {
63565     try {
63566       result = Dali::Toolkit::Alignment::DownCast(arg1);
63567     } catch (std::out_of_range& e) {
63568       {
63569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (std::exception& e) {
63572       {
63573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63578       };
63579     }
63580   }
63581   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63582   return jresult;
63583 }
63584
63585
63586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63587   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63588   Dali::Toolkit::Alignment::Type arg2 ;
63589
63590   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63591   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63592   {
63593     try {
63594       (arg1)->SetAlignmentType(arg2);
63595     } catch (std::out_of_range& e) {
63596       {
63597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63598       };
63599     } catch (std::exception& e) {
63600       {
63601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63602       };
63603     } catch (...) {
63604       {
63605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63606       };
63607     }
63608   }
63609 }
63610
63611
63612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63613   int jresult ;
63614   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63615   Dali::Toolkit::Alignment::Type result;
63616
63617   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63618   {
63619     try {
63620       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63621     } catch (std::out_of_range& e) {
63622       {
63623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63624       };
63625     } catch (std::exception& e) {
63626       {
63627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63628       };
63629     } catch (...) {
63630       {
63631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63632       };
63633     }
63634   }
63635   jresult = (int)result;
63636   return jresult;
63637 }
63638
63639
63640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63641   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63642   Dali::Toolkit::Alignment::Scaling arg2 ;
63643
63644   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63645   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63646   {
63647     try {
63648       (arg1)->SetScaling(arg2);
63649     } catch (std::out_of_range& e) {
63650       {
63651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63652       };
63653     } catch (std::exception& e) {
63654       {
63655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63656       };
63657     } catch (...) {
63658       {
63659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63660       };
63661     }
63662   }
63663 }
63664
63665
63666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63667   int jresult ;
63668   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63669   Dali::Toolkit::Alignment::Scaling result;
63670
63671   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63672   {
63673     try {
63674       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63675     } catch (std::out_of_range& e) {
63676       {
63677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63678       };
63679     } catch (std::exception& e) {
63680       {
63681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63682       };
63683     } catch (...) {
63684       {
63685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63686       };
63687     }
63688   }
63689   jresult = (int)result;
63690   return jresult;
63691 }
63692
63693
63694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63695   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63696   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63697
63698   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63699   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63700   if (!arg2) {
63701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63702     return ;
63703   }
63704   {
63705     try {
63706       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63707     } catch (std::out_of_range& e) {
63708       {
63709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63710       };
63711     } catch (std::exception& e) {
63712       {
63713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63714       };
63715     } catch (...) {
63716       {
63717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63718       };
63719     }
63720   }
63721 }
63722
63723
63724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63725   void * jresult ;
63726   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63727   Dali::Toolkit::Alignment::Padding *result = 0 ;
63728
63729   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63730   {
63731     try {
63732       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63733     } catch (std::out_of_range& e) {
63734       {
63735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63736       };
63737     } catch (std::exception& e) {
63738       {
63739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (...) {
63742       {
63743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63744       };
63745     }
63746   }
63747   jresult = (void *)result;
63748   return jresult;
63749 }
63750
63751
63752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63753   void * jresult ;
63754   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63755   Dali::Toolkit::Alignment *arg2 = 0 ;
63756   Dali::Toolkit::Alignment *result = 0 ;
63757
63758   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63759   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63760   if (!arg2) {
63761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63762     return 0;
63763   }
63764   {
63765     try {
63766       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63767     } catch (std::out_of_range& e) {
63768       {
63769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (std::exception& e) {
63772       {
63773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781   jresult = (void *)result;
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63787   int jresult ;
63788   int result;
63789
63790   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63791   jresult = (int)result;
63792   return jresult;
63793 }
63794
63795
63796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63797   int jresult ;
63798   int result;
63799
63800   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63801   jresult = (int)result;
63802   return jresult;
63803 }
63804
63805
63806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63807   int jresult ;
63808   int result;
63809
63810   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63811   jresult = (int)result;
63812   return jresult;
63813 }
63814
63815
63816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63817   int jresult ;
63818   int result;
63819
63820   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63821   jresult = (int)result;
63822   return jresult;
63823 }
63824
63825
63826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63827   int jresult ;
63828   int result;
63829
63830   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63831   jresult = (int)result;
63832   return jresult;
63833 }
63834
63835
63836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63837   int jresult ;
63838   int result;
63839
63840   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63841   jresult = (int)result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63847   int jresult ;
63848   int result;
63849
63850   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63851   jresult = (int)result;
63852   return jresult;
63853 }
63854
63855
63856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63857   int jresult ;
63858   int result;
63859
63860   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63861   jresult = (int)result;
63862   return jresult;
63863 }
63864
63865
63866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63867   int jresult ;
63868   int result;
63869
63870   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63871   jresult = (int)result;
63872   return jresult;
63873 }
63874
63875
63876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63877   int jresult ;
63878   int result;
63879
63880   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63881   jresult = (int)result;
63882   return jresult;
63883 }
63884
63885
63886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63887   int jresult ;
63888   int result;
63889
63890   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63891   jresult = (int)result;
63892   return jresult;
63893 }
63894
63895
63896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63897   int jresult ;
63898   int result;
63899
63900   result = (int)Dali::Toolkit::Button::Property::LABEL;
63901   jresult = (int)result;
63902   return jresult;
63903 }
63904
63905
63906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63907   int jresult ;
63908   int result;
63909
63910   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63911   jresult = (int)result;
63912   return jresult;
63913 }
63914
63915
63916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63917   void * jresult ;
63918   Dali::Toolkit::Button::Property *result = 0 ;
63919
63920   {
63921     try {
63922       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63923     } catch (std::out_of_range& e) {
63924       {
63925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63926       };
63927     } catch (std::exception& e) {
63928       {
63929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63930       };
63931     } catch (...) {
63932       {
63933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63934       };
63935     }
63936   }
63937   jresult = (void *)result;
63938   return jresult;
63939 }
63940
63941
63942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63943   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63944
63945   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63946   {
63947     try {
63948       delete arg1;
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63960       };
63961     }
63962   }
63963 }
63964
63965
63966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63967   void * jresult ;
63968   Dali::Toolkit::Button *result = 0 ;
63969
63970   {
63971     try {
63972       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63973     } catch (std::out_of_range& e) {
63974       {
63975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63976       };
63977     } catch (std::exception& e) {
63978       {
63979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63980       };
63981     } catch (...) {
63982       {
63983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63984       };
63985     }
63986   }
63987   jresult = (void *)result;
63988   return jresult;
63989 }
63990
63991
63992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
63993   void * jresult ;
63994   Dali::Toolkit::Button *arg1 = 0 ;
63995   Dali::Toolkit::Button *result = 0 ;
63996
63997   arg1 = (Dali::Toolkit::Button *)jarg1;
63998   if (!arg1) {
63999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64000     return 0;
64001   }
64002   {
64003     try {
64004       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019   jresult = (void *)result;
64020   return jresult;
64021 }
64022
64023
64024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64025   void * jresult ;
64026   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64027   Dali::Toolkit::Button *arg2 = 0 ;
64028   Dali::Toolkit::Button *result = 0 ;
64029
64030   arg1 = (Dali::Toolkit::Button *)jarg1;
64031   arg2 = (Dali::Toolkit::Button *)jarg2;
64032   if (!arg2) {
64033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64034     return 0;
64035   }
64036   {
64037     try {
64038       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64039     } catch (std::out_of_range& e) {
64040       {
64041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64042       };
64043     } catch (std::exception& e) {
64044       {
64045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64046       };
64047     } catch (...) {
64048       {
64049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64050       };
64051     }
64052   }
64053   jresult = (void *)result;
64054   return jresult;
64055 }
64056
64057
64058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64059   void * jresult ;
64060   Dali::BaseHandle arg1 ;
64061   Dali::BaseHandle *argp1 ;
64062   Dali::Toolkit::Button result;
64063
64064   argp1 = (Dali::BaseHandle *)jarg1;
64065   if (!argp1) {
64066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64067     return 0;
64068   }
64069   arg1 = *argp1;
64070   {
64071     try {
64072       result = Dali::Toolkit::Button::DownCast(arg1);
64073     } catch (std::out_of_range& e) {
64074       {
64075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64076       };
64077     } catch (std::exception& e) {
64078       {
64079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64080       };
64081     } catch (...) {
64082       {
64083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64084       };
64085     }
64086   }
64087   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64088   return jresult;
64089 }
64090
64091
64092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64093   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64094
64095   arg1 = (Dali::Toolkit::Button *)jarg1;
64096   {
64097     try {
64098       delete arg1;
64099     } catch (std::out_of_range& e) {
64100       {
64101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64102       };
64103     } catch (std::exception& e) {
64104       {
64105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64106       };
64107     } catch (...) {
64108       {
64109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64110       };
64111     }
64112   }
64113 }
64114
64115
64116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64117   unsigned int jresult ;
64118   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64119   bool result;
64120
64121   arg1 = (Dali::Toolkit::Button *)jarg1;
64122   {
64123     try {
64124       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64125     } catch (std::out_of_range& e) {
64126       {
64127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64128       };
64129     } catch (std::exception& e) {
64130       {
64131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64132       };
64133     } catch (...) {
64134       {
64135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64136       };
64137     }
64138   }
64139   jresult = result;
64140   return jresult;
64141 }
64142
64143
64144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64145   unsigned int jresult ;
64146   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64147   bool result;
64148
64149   arg1 = (Dali::Toolkit::Button *)jarg1;
64150   {
64151     try {
64152       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64153     } catch (std::out_of_range& e) {
64154       {
64155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64156       };
64157     } catch (std::exception& e) {
64158       {
64159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64160       };
64161     } catch (...) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64164       };
64165     }
64166   }
64167   jresult = result;
64168   return jresult;
64169 }
64170
64171
64172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64173   float jresult ;
64174   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64175   float result;
64176
64177   arg1 = (Dali::Toolkit::Button *)jarg1;
64178   {
64179     try {
64180       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64181     } catch (std::out_of_range& e) {
64182       {
64183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64184       };
64185     } catch (std::exception& e) {
64186       {
64187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64188       };
64189     } catch (...) {
64190       {
64191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64192       };
64193     }
64194   }
64195   jresult = result;
64196   return jresult;
64197 }
64198
64199
64200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64201   float jresult ;
64202   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64203   float result;
64204
64205   arg1 = (Dali::Toolkit::Button *)jarg1;
64206   {
64207     try {
64208       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64209     } catch (std::out_of_range& e) {
64210       {
64211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64212       };
64213     } catch (std::exception& e) {
64214       {
64215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64216       };
64217     } catch (...) {
64218       {
64219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64220       };
64221     }
64222   }
64223   jresult = result;
64224   return jresult;
64225 }
64226
64227
64228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64229   unsigned int jresult ;
64230   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64231   bool result;
64232
64233   arg1 = (Dali::Toolkit::Button *)jarg1;
64234   {
64235     try {
64236       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64237     } catch (std::out_of_range& e) {
64238       {
64239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64240       };
64241     } catch (std::exception& e) {
64242       {
64243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64244       };
64245     } catch (...) {
64246       {
64247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64248       };
64249     }
64250   }
64251   jresult = result;
64252   return jresult;
64253 }
64254
64255
64256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64257   unsigned int jresult ;
64258   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64259   bool result;
64260
64261   arg1 = (Dali::Toolkit::Button *)jarg1;
64262   {
64263     try {
64264       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64272       };
64273     } catch (...) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64276       };
64277     }
64278   }
64279   jresult = result;
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64285   float jresult ;
64286   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64287   float result;
64288
64289   arg1 = (Dali::Toolkit::Button *)jarg1;
64290   {
64291     try {
64292       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64293     } catch (std::out_of_range& e) {
64294       {
64295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64296       };
64297     } catch (std::exception& e) {
64298       {
64299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64300       };
64301     } catch (...) {
64302       {
64303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64304       };
64305     }
64306   }
64307   jresult = result;
64308   return jresult;
64309 }
64310
64311
64312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64313   char * jresult ;
64314   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64315   std::string result;
64316
64317   arg1 = (Dali::Toolkit::Button *)jarg1;
64318   {
64319     try {
64320       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64321     } catch (std::out_of_range& e) {
64322       {
64323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (std::exception& e) {
64326       {
64327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64328       };
64329     } catch (...) {
64330       {
64331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64332       };
64333     }
64334   }
64335   jresult = SWIG_csharp_string_callback((&result)->c_str());
64336   return jresult;
64337 }
64338
64339
64340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64341   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64342   Dali::Actor arg2 ;
64343   Dali::Actor *argp2 ;
64344
64345   arg1 = (Dali::Toolkit::Button *)jarg1;
64346   argp2 = (Dali::Actor *)jarg2;
64347   if (!argp2) {
64348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64349     return ;
64350   }
64351   arg2 = *argp2;
64352   {
64353     try {
64354       (arg1)->SetLabel(arg2);
64355     } catch (std::out_of_range& e) {
64356       {
64357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64358       };
64359     } catch (std::exception& e) {
64360       {
64361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64362       };
64363     } catch (...) {
64364       {
64365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64366       };
64367     }
64368   }
64369 }
64370
64371
64372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64373   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64374   Dali::Image arg2 ;
64375   Dali::Image *argp2 ;
64376
64377   arg1 = (Dali::Toolkit::Button *)jarg1;
64378   argp2 = (Dali::Image *)jarg2;
64379   if (!argp2) {
64380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64381     return ;
64382   }
64383   arg2 = *argp2;
64384   {
64385     try {
64386       (arg1)->SetButtonImage(arg2);
64387     } catch (std::out_of_range& e) {
64388       {
64389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64390       };
64391     } catch (std::exception& e) {
64392       {
64393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64394       };
64395     } catch (...) {
64396       {
64397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64398       };
64399     }
64400   }
64401 }
64402
64403
64404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64405   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64406   Dali::Image arg2 ;
64407   Dali::Image *argp2 ;
64408
64409   arg1 = (Dali::Toolkit::Button *)jarg1;
64410   argp2 = (Dali::Image *)jarg2;
64411   if (!argp2) {
64412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64413     return ;
64414   }
64415   arg2 = *argp2;
64416   {
64417     try {
64418       (arg1)->SetSelectedImage(arg2);
64419     } catch (std::out_of_range& e) {
64420       {
64421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64422       };
64423     } catch (std::exception& e) {
64424       {
64425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64426       };
64427     } catch (...) {
64428       {
64429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64430       };
64431     }
64432   }
64433 }
64434
64435
64436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64437   void * jresult ;
64438   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64439   Dali::Actor result;
64440
64441   arg1 = (Dali::Toolkit::Button *)jarg1;
64442   {
64443     try {
64444       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64445     } catch (std::out_of_range& e) {
64446       {
64447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64448       };
64449     } catch (std::exception& e) {
64450       {
64451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64452       };
64453     } catch (...) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64456       };
64457     }
64458   }
64459   jresult = new Dali::Actor((const Dali::Actor &)result);
64460   return jresult;
64461 }
64462
64463
64464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64465   void * jresult ;
64466   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64467   Dali::Actor result;
64468
64469   arg1 = (Dali::Toolkit::Button *)jarg1;
64470   {
64471     try {
64472       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64473     } catch (std::out_of_range& e) {
64474       {
64475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64476       };
64477     } catch (std::exception& e) {
64478       {
64479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64484       };
64485     }
64486   }
64487   jresult = new Dali::Actor((const Dali::Actor &)result);
64488   return jresult;
64489 }
64490
64491
64492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64493   void * jresult ;
64494   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64495   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64496
64497   arg1 = (Dali::Toolkit::Button *)jarg1;
64498   {
64499     try {
64500       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64501     } catch (std::out_of_range& e) {
64502       {
64503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64504       };
64505     } catch (std::exception& e) {
64506       {
64507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64508       };
64509     } catch (...) {
64510       {
64511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64512       };
64513     }
64514   }
64515   jresult = (void *)result;
64516   return jresult;
64517 }
64518
64519
64520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64521   void * jresult ;
64522   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64523   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64524
64525   arg1 = (Dali::Toolkit::Button *)jarg1;
64526   {
64527     try {
64528       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64529     } catch (std::out_of_range& e) {
64530       {
64531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64532       };
64533     } catch (std::exception& e) {
64534       {
64535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64536       };
64537     } catch (...) {
64538       {
64539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64540       };
64541     }
64542   }
64543   jresult = (void *)result;
64544   return jresult;
64545 }
64546
64547
64548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64549   void * jresult ;
64550   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64551   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64552
64553   arg1 = (Dali::Toolkit::Button *)jarg1;
64554   {
64555     try {
64556       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64557     } catch (std::out_of_range& e) {
64558       {
64559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64560       };
64561     } catch (std::exception& e) {
64562       {
64563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64564       };
64565     } catch (...) {
64566       {
64567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64568       };
64569     }
64570   }
64571   jresult = (void *)result;
64572   return jresult;
64573 }
64574
64575
64576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64577   void * jresult ;
64578   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64579   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64580
64581   arg1 = (Dali::Toolkit::Button *)jarg1;
64582   {
64583     try {
64584       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64585     } catch (std::out_of_range& e) {
64586       {
64587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64588       };
64589     } catch (std::exception& e) {
64590       {
64591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64592       };
64593     } catch (...) {
64594       {
64595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64596       };
64597     }
64598   }
64599   jresult = (void *)result;
64600   return jresult;
64601 }
64602
64603
64604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64605   void * jresult ;
64606   Dali::Toolkit::CheckBoxButton *result = 0 ;
64607
64608   {
64609     try {
64610       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (...) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64622       };
64623     }
64624   }
64625   jresult = (void *)result;
64626   return jresult;
64627 }
64628
64629
64630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64631   void * jresult ;
64632   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64633   Dali::Toolkit::CheckBoxButton *result = 0 ;
64634
64635   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64636   if (!arg1) {
64637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64638     return 0;
64639   }
64640   {
64641     try {
64642       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64643     } catch (std::out_of_range& e) {
64644       {
64645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64646       };
64647     } catch (std::exception& e) {
64648       {
64649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64650       };
64651     } catch (...) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64654       };
64655     }
64656   }
64657   jresult = (void *)result;
64658   return jresult;
64659 }
64660
64661
64662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64663   void * jresult ;
64664   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64665   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64666   Dali::Toolkit::CheckBoxButton *result = 0 ;
64667
64668   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64669   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64670   if (!arg2) {
64671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64672     return 0;
64673   }
64674   {
64675     try {
64676       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64677     } catch (std::out_of_range& e) {
64678       {
64679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64680       };
64681     } catch (std::exception& e) {
64682       {
64683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (...) {
64686       {
64687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64688       };
64689     }
64690   }
64691   jresult = (void *)result;
64692   return jresult;
64693 }
64694
64695
64696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64697   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64698
64699   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64700   {
64701     try {
64702       delete arg1;
64703     } catch (std::out_of_range& e) {
64704       {
64705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64706       };
64707     } catch (std::exception& e) {
64708       {
64709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64710       };
64711     } catch (...) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64714       };
64715     }
64716   }
64717 }
64718
64719
64720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64721   void * jresult ;
64722   Dali::Toolkit::CheckBoxButton result;
64723
64724   {
64725     try {
64726       result = Dali::Toolkit::CheckBoxButton::New();
64727     } catch (std::out_of_range& e) {
64728       {
64729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64730       };
64731     } catch (std::exception& e) {
64732       {
64733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64734       };
64735     } catch (...) {
64736       {
64737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64738       };
64739     }
64740   }
64741   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64742   return jresult;
64743 }
64744
64745
64746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64747   void * jresult ;
64748   Dali::BaseHandle arg1 ;
64749   Dali::BaseHandle *argp1 ;
64750   Dali::Toolkit::CheckBoxButton result;
64751
64752   argp1 = (Dali::BaseHandle *)jarg1;
64753   if (!argp1) {
64754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64755     return 0;
64756   }
64757   arg1 = *argp1;
64758   {
64759     try {
64760       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64761     } catch (std::out_of_range& e) {
64762       {
64763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64764       };
64765     } catch (std::exception& e) {
64766       {
64767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64768       };
64769     } catch (...) {
64770       {
64771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64772       };
64773     }
64774   }
64775   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64776   return jresult;
64777 }
64778
64779
64780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64781   int jresult ;
64782   int result;
64783
64784   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64785   jresult = (int)result;
64786   return jresult;
64787 }
64788
64789
64790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64791   int jresult ;
64792   int result;
64793
64794   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64795   jresult = (int)result;
64796   return jresult;
64797 }
64798
64799
64800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64801   int jresult ;
64802   int result;
64803
64804   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64805   jresult = (int)result;
64806   return jresult;
64807 }
64808
64809
64810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64811   int jresult ;
64812   int result;
64813
64814   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64815   jresult = (int)result;
64816   return jresult;
64817 }
64818
64819
64820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64821   int jresult ;
64822   int result;
64823
64824   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64825   jresult = (int)result;
64826   return jresult;
64827 }
64828
64829
64830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64831   void * jresult ;
64832   Dali::Toolkit::PushButton::Property *result = 0 ;
64833
64834   {
64835     try {
64836       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64837     } catch (std::out_of_range& e) {
64838       {
64839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64840       };
64841     } catch (std::exception& e) {
64842       {
64843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64844       };
64845     } catch (...) {
64846       {
64847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64848       };
64849     }
64850   }
64851   jresult = (void *)result;
64852   return jresult;
64853 }
64854
64855
64856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64857   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64858
64859   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64860   {
64861     try {
64862       delete arg1;
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64870       };
64871     } catch (...) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64874       };
64875     }
64876   }
64877 }
64878
64879
64880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64881   void * jresult ;
64882   Dali::Toolkit::PushButton *result = 0 ;
64883
64884   {
64885     try {
64886       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64887     } catch (std::out_of_range& e) {
64888       {
64889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64890       };
64891     } catch (std::exception& e) {
64892       {
64893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64894       };
64895     } catch (...) {
64896       {
64897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64898       };
64899     }
64900   }
64901   jresult = (void *)result;
64902   return jresult;
64903 }
64904
64905
64906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64907   void * jresult ;
64908   Dali::Toolkit::PushButton *arg1 = 0 ;
64909   Dali::Toolkit::PushButton *result = 0 ;
64910
64911   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64912   if (!arg1) {
64913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64914     return 0;
64915   }
64916   {
64917     try {
64918       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64919     } catch (std::out_of_range& e) {
64920       {
64921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64922       };
64923     } catch (std::exception& e) {
64924       {
64925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64926       };
64927     } catch (...) {
64928       {
64929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64930       };
64931     }
64932   }
64933   jresult = (void *)result;
64934   return jresult;
64935 }
64936
64937
64938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64939   void * jresult ;
64940   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64941   Dali::Toolkit::PushButton *arg2 = 0 ;
64942   Dali::Toolkit::PushButton *result = 0 ;
64943
64944   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64945   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64946   if (!arg2) {
64947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64948     return 0;
64949   }
64950   {
64951     try {
64952       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
64953     } catch (std::out_of_range& e) {
64954       {
64955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64956       };
64957     } catch (std::exception& e) {
64958       {
64959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (...) {
64962       {
64963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64964       };
64965     }
64966   }
64967   jresult = (void *)result;
64968   return jresult;
64969 }
64970
64971
64972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64973   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64974
64975   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64976   {
64977     try {
64978       delete arg1;
64979     } catch (std::out_of_range& e) {
64980       {
64981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64982       };
64983     } catch (std::exception& e) {
64984       {
64985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64986       };
64987     } catch (...) {
64988       {
64989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64990       };
64991     }
64992   }
64993 }
64994
64995
64996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
64997   void * jresult ;
64998   Dali::Toolkit::PushButton result;
64999
65000   {
65001     try {
65002       result = Dali::Toolkit::PushButton::New();
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (...) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65014       };
65015     }
65016   }
65017   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65018   return jresult;
65019 }
65020
65021
65022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65023   void * jresult ;
65024   Dali::BaseHandle arg1 ;
65025   Dali::BaseHandle *argp1 ;
65026   Dali::Toolkit::PushButton result;
65027
65028   argp1 = (Dali::BaseHandle *)jarg1;
65029   if (!argp1) {
65030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65031     return 0;
65032   }
65033   arg1 = *argp1;
65034   {
65035     try {
65036       result = Dali::Toolkit::PushButton::DownCast(arg1);
65037     } catch (std::out_of_range& e) {
65038       {
65039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65040       };
65041     } catch (std::exception& e) {
65042       {
65043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65044       };
65045     } catch (...) {
65046       {
65047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65048       };
65049     }
65050   }
65051   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65052   return jresult;
65053 }
65054
65055
65056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65057   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65058   Dali::Image arg2 ;
65059   Dali::Image *argp2 ;
65060
65061   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65062   argp2 = (Dali::Image *)jarg2;
65063   if (!argp2) {
65064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65065     return ;
65066   }
65067   arg2 = *argp2;
65068   {
65069     try {
65070       (arg1)->SetButtonImage(arg2);
65071     } catch (std::out_of_range& e) {
65072       {
65073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65074       };
65075     } catch (std::exception& e) {
65076       {
65077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65078       };
65079     } catch (...) {
65080       {
65081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65082       };
65083     }
65084   }
65085 }
65086
65087
65088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65089   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65090   Dali::Actor arg2 ;
65091   Dali::Actor *argp2 ;
65092
65093   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65094   argp2 = (Dali::Actor *)jarg2;
65095   if (!argp2) {
65096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65097     return ;
65098   }
65099   arg2 = *argp2;
65100   {
65101     try {
65102       (arg1)->SetButtonImage(arg2);
65103     } catch (std::out_of_range& e) {
65104       {
65105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65106       };
65107     } catch (std::exception& e) {
65108       {
65109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65110       };
65111     } catch (...) {
65112       {
65113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65114       };
65115     }
65116   }
65117 }
65118
65119
65120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65121   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65122   Dali::Actor arg2 ;
65123   Dali::Actor *argp2 ;
65124
65125   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65126   argp2 = (Dali::Actor *)jarg2;
65127   if (!argp2) {
65128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65129     return ;
65130   }
65131   arg2 = *argp2;
65132   {
65133     try {
65134       (arg1)->SetBackgroundImage(arg2);
65135     } catch (std::out_of_range& e) {
65136       {
65137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65138       };
65139     } catch (std::exception& e) {
65140       {
65141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65142       };
65143     } catch (...) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65146       };
65147     }
65148   }
65149 }
65150
65151
65152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65153   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65154   Dali::Image arg2 ;
65155   Dali::Image *argp2 ;
65156
65157   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65158   argp2 = (Dali::Image *)jarg2;
65159   if (!argp2) {
65160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65161     return ;
65162   }
65163   arg2 = *argp2;
65164   {
65165     try {
65166       (arg1)->SetSelectedImage(arg2);
65167     } catch (std::out_of_range& e) {
65168       {
65169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65170       };
65171     } catch (std::exception& e) {
65172       {
65173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65174       };
65175     } catch (...) {
65176       {
65177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65178       };
65179     }
65180   }
65181 }
65182
65183
65184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65185   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65186   Dali::Actor arg2 ;
65187   Dali::Actor *argp2 ;
65188
65189   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65190   argp2 = (Dali::Actor *)jarg2;
65191   if (!argp2) {
65192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65193     return ;
65194   }
65195   arg2 = *argp2;
65196   {
65197     try {
65198       (arg1)->SetSelectedImage(arg2);
65199     } catch (std::out_of_range& e) {
65200       {
65201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65202       };
65203     } catch (std::exception& e) {
65204       {
65205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65206       };
65207     } catch (...) {
65208       {
65209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65210       };
65211     }
65212   }
65213 }
65214
65215
65216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65217   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65218   Dali::Actor arg2 ;
65219   Dali::Actor *argp2 ;
65220
65221   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65222   argp2 = (Dali::Actor *)jarg2;
65223   if (!argp2) {
65224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65225     return ;
65226   }
65227   arg2 = *argp2;
65228   {
65229     try {
65230       (arg1)->SetSelectedBackgroundImage(arg2);
65231     } catch (std::out_of_range& e) {
65232       {
65233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65234       };
65235     } catch (std::exception& e) {
65236       {
65237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65238       };
65239     } catch (...) {
65240       {
65241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65242       };
65243     }
65244   }
65245 }
65246
65247
65248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65249   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65250   Dali::Actor arg2 ;
65251   Dali::Actor *argp2 ;
65252
65253   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65254   argp2 = (Dali::Actor *)jarg2;
65255   if (!argp2) {
65256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65257     return ;
65258   }
65259   arg2 = *argp2;
65260   {
65261     try {
65262       (arg1)->SetDisabledBackgroundImage(arg2);
65263     } catch (std::out_of_range& e) {
65264       {
65265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65266       };
65267     } catch (std::exception& e) {
65268       {
65269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65270       };
65271     } catch (...) {
65272       {
65273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65274       };
65275     }
65276   }
65277 }
65278
65279
65280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65281   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65282   Dali::Actor arg2 ;
65283   Dali::Actor *argp2 ;
65284
65285   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65286   argp2 = (Dali::Actor *)jarg2;
65287   if (!argp2) {
65288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65289     return ;
65290   }
65291   arg2 = *argp2;
65292   {
65293     try {
65294       (arg1)->SetDisabledImage(arg2);
65295     } catch (std::out_of_range& e) {
65296       {
65297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65298       };
65299     } catch (std::exception& e) {
65300       {
65301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65302       };
65303     } catch (...) {
65304       {
65305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65306       };
65307     }
65308   }
65309 }
65310
65311
65312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65313   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65314   Dali::Actor arg2 ;
65315   Dali::Actor *argp2 ;
65316
65317   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65318   argp2 = (Dali::Actor *)jarg2;
65319   if (!argp2) {
65320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65321     return ;
65322   }
65323   arg2 = *argp2;
65324   {
65325     try {
65326       (arg1)->SetDisabledSelectedImage(arg2);
65327     } catch (std::out_of_range& e) {
65328       {
65329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65330       };
65331     } catch (std::exception& e) {
65332       {
65333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65334       };
65335     } catch (...) {
65336       {
65337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65338       };
65339     }
65340   }
65341 }
65342
65343
65344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65345   void * jresult ;
65346   Dali::Toolkit::RadioButton *result = 0 ;
65347
65348   {
65349     try {
65350       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65351     } catch (std::out_of_range& e) {
65352       {
65353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65354       };
65355     } catch (std::exception& e) {
65356       {
65357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65358       };
65359     } catch (...) {
65360       {
65361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65362       };
65363     }
65364   }
65365   jresult = (void *)result;
65366   return jresult;
65367 }
65368
65369
65370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65371   void * jresult ;
65372   Dali::Toolkit::RadioButton *arg1 = 0 ;
65373   Dali::Toolkit::RadioButton *result = 0 ;
65374
65375   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65376   if (!arg1) {
65377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65378     return 0;
65379   }
65380   {
65381     try {
65382       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65383     } catch (std::out_of_range& e) {
65384       {
65385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65386       };
65387     } catch (std::exception& e) {
65388       {
65389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65390       };
65391     } catch (...) {
65392       {
65393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65394       };
65395     }
65396   }
65397   jresult = (void *)result;
65398   return jresult;
65399 }
65400
65401
65402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65403   void * jresult ;
65404   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65405   Dali::Toolkit::RadioButton *arg2 = 0 ;
65406   Dali::Toolkit::RadioButton *result = 0 ;
65407
65408   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65409   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65410   if (!arg2) {
65411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65412     return 0;
65413   }
65414   {
65415     try {
65416       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65417     } catch (std::out_of_range& e) {
65418       {
65419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65420       };
65421     } catch (std::exception& e) {
65422       {
65423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65424       };
65425     } catch (...) {
65426       {
65427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65428       };
65429     }
65430   }
65431   jresult = (void *)result;
65432   return jresult;
65433 }
65434
65435
65436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65437   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65438
65439   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65440   {
65441     try {
65442       delete arg1;
65443     } catch (std::out_of_range& e) {
65444       {
65445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65446       };
65447     } catch (std::exception& e) {
65448       {
65449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65450       };
65451     } catch (...) {
65452       {
65453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65454       };
65455     }
65456   }
65457 }
65458
65459
65460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65461   void * jresult ;
65462   Dali::Toolkit::RadioButton result;
65463
65464   {
65465     try {
65466       result = Dali::Toolkit::RadioButton::New();
65467     } catch (std::out_of_range& e) {
65468       {
65469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65470       };
65471     } catch (std::exception& e) {
65472       {
65473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65474       };
65475     } catch (...) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65478       };
65479     }
65480   }
65481   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65482   return jresult;
65483 }
65484
65485
65486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65487   void * jresult ;
65488   std::string *arg1 = 0 ;
65489   Dali::Toolkit::RadioButton result;
65490
65491   if (!jarg1) {
65492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65493     return 0;
65494   }
65495   std::string arg1_str(jarg1);
65496   arg1 = &arg1_str;
65497   {
65498     try {
65499       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65500     } catch (std::out_of_range& e) {
65501       {
65502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65503       };
65504     } catch (std::exception& e) {
65505       {
65506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65511       };
65512     }
65513   }
65514   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65515
65516   //argout typemap for const std::string&
65517
65518   return jresult;
65519 }
65520
65521
65522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65523   void * jresult ;
65524   Dali::BaseHandle arg1 ;
65525   Dali::BaseHandle *argp1 ;
65526   Dali::Toolkit::RadioButton result;
65527
65528   argp1 = (Dali::BaseHandle *)jarg1;
65529   if (!argp1) {
65530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65531     return 0;
65532   }
65533   arg1 = *argp1;
65534   {
65535     try {
65536       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65537     } catch (std::out_of_range& e) {
65538       {
65539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65540       };
65541     } catch (std::exception& e) {
65542       {
65543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65544       };
65545     } catch (...) {
65546       {
65547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65548       };
65549     }
65550   }
65551   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65552   return jresult;
65553 }
65554
65555
65556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65557   int jresult ;
65558   int result;
65559
65560   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65561   jresult = (int)result;
65562   return jresult;
65563 }
65564
65565
65566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65567   int jresult ;
65568   int result;
65569
65570   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65571   jresult = (int)result;
65572   return jresult;
65573 }
65574
65575
65576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65577   int jresult ;
65578   int result;
65579
65580   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65581   jresult = (int)result;
65582   return jresult;
65583 }
65584
65585
65586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65587   int jresult ;
65588   int result;
65589
65590   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65591   jresult = (int)result;
65592   return jresult;
65593 }
65594
65595
65596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65597   int jresult ;
65598   int result;
65599
65600   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65601   jresult = (int)result;
65602   return jresult;
65603 }
65604
65605
65606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65607   int jresult ;
65608   int result;
65609
65610   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65611   jresult = (int)result;
65612   return jresult;
65613 }
65614
65615
65616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65617   void * jresult ;
65618   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65619
65620   {
65621     try {
65622       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65623     } catch (std::out_of_range& e) {
65624       {
65625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65626       };
65627     } catch (std::exception& e) {
65628       {
65629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65630       };
65631     } catch (...) {
65632       {
65633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65634       };
65635     }
65636   }
65637   jresult = (void *)result;
65638   return jresult;
65639 }
65640
65641
65642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65643   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65644
65645   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65646   {
65647     try {
65648       delete arg1;
65649     } catch (std::out_of_range& e) {
65650       {
65651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65652       };
65653     } catch (std::exception& e) {
65654       {
65655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65656       };
65657     } catch (...) {
65658       {
65659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65660       };
65661     }
65662   }
65663 }
65664
65665
65666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65667   int jresult ;
65668   int result;
65669
65670   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65671   jresult = (int)result;
65672   return jresult;
65673 }
65674
65675
65676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65677   int jresult ;
65678   int result;
65679
65680   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65681   jresult = (int)result;
65682   return jresult;
65683 }
65684
65685
65686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65687   int jresult ;
65688   int result;
65689
65690   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65691   jresult = (int)result;
65692   return jresult;
65693 }
65694
65695
65696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65697   void * jresult ;
65698   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65699
65700   {
65701     try {
65702       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (...) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65714       };
65715     }
65716   }
65717   jresult = (void *)result;
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65723   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65724
65725   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65726   {
65727     try {
65728       delete arg1;
65729     } catch (std::out_of_range& e) {
65730       {
65731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65732       };
65733     } catch (std::exception& e) {
65734       {
65735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65736       };
65737     } catch (...) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65740       };
65741     }
65742   }
65743 }
65744
65745
65746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65747   void * jresult ;
65748   Dali::Toolkit::FlexContainer *result = 0 ;
65749
65750   {
65751     try {
65752       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65753     } catch (std::out_of_range& e) {
65754       {
65755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65756       };
65757     } catch (std::exception& e) {
65758       {
65759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65760       };
65761     } catch (...) {
65762       {
65763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65764       };
65765     }
65766   }
65767   jresult = (void *)result;
65768   return jresult;
65769 }
65770
65771
65772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65773   void * jresult ;
65774   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65775   Dali::Toolkit::FlexContainer *result = 0 ;
65776
65777   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65778   if (!arg1) {
65779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65780     return 0;
65781   }
65782   {
65783     try {
65784       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65785     } catch (std::out_of_range& e) {
65786       {
65787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65788       };
65789     } catch (std::exception& e) {
65790       {
65791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65792       };
65793     } catch (...) {
65794       {
65795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65796       };
65797     }
65798   }
65799   jresult = (void *)result;
65800   return jresult;
65801 }
65802
65803
65804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65805   void * jresult ;
65806   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65807   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65808   Dali::Toolkit::FlexContainer *result = 0 ;
65809
65810   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65811   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65812   if (!arg2) {
65813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65814     return 0;
65815   }
65816   {
65817     try {
65818       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65819     } catch (std::out_of_range& e) {
65820       {
65821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65822       };
65823     } catch (std::exception& e) {
65824       {
65825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65826       };
65827     } catch (...) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65830       };
65831     }
65832   }
65833   jresult = (void *)result;
65834   return jresult;
65835 }
65836
65837
65838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65839   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65840
65841   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65842   {
65843     try {
65844       delete arg1;
65845     } catch (std::out_of_range& e) {
65846       {
65847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65848       };
65849     } catch (std::exception& e) {
65850       {
65851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65852       };
65853     } catch (...) {
65854       {
65855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65856       };
65857     }
65858   }
65859 }
65860
65861
65862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65863   void * jresult ;
65864   Dali::Toolkit::FlexContainer result;
65865
65866   {
65867     try {
65868       result = Dali::Toolkit::FlexContainer::New();
65869     } catch (std::out_of_range& e) {
65870       {
65871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65872       };
65873     } catch (std::exception& e) {
65874       {
65875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65876       };
65877     } catch (...) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65880       };
65881     }
65882   }
65883   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65884   return jresult;
65885 }
65886
65887
65888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65889   void * jresult ;
65890   Dali::BaseHandle arg1 ;
65891   Dali::BaseHandle *argp1 ;
65892   Dali::Toolkit::FlexContainer result;
65893
65894   argp1 = (Dali::BaseHandle *)jarg1;
65895   if (!argp1) {
65896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65897     return 0;
65898   }
65899   arg1 = *argp1;
65900   {
65901     try {
65902       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65903     } catch (std::out_of_range& e) {
65904       {
65905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65906       };
65907     } catch (std::exception& e) {
65908       {
65909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65910       };
65911     } catch (...) {
65912       {
65913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65914       };
65915     }
65916   }
65917   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65918   return jresult;
65919 }
65920
65921
65922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65923   int jresult ;
65924   int result;
65925
65926   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65927   jresult = (int)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65933   int jresult ;
65934   int result;
65935
65936   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65937   jresult = (int)result;
65938   return jresult;
65939 }
65940
65941
65942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65943   int jresult ;
65944   int result;
65945
65946   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65947   jresult = (int)result;
65948   return jresult;
65949 }
65950
65951
65952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65953   int jresult ;
65954   int result;
65955
65956   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65957   jresult = (int)result;
65958   return jresult;
65959 }
65960
65961
65962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65963   void * jresult ;
65964   Dali::Toolkit::ImageView::Property *result = 0 ;
65965
65966   {
65967     try {
65968       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
65969     } catch (std::out_of_range& e) {
65970       {
65971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65972       };
65973     } catch (std::exception& e) {
65974       {
65975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65976       };
65977     } catch (...) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65980       };
65981     }
65982   }
65983   jresult = (void *)result;
65984   return jresult;
65985 }
65986
65987
65988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65989   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65990
65991   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65992   {
65993     try {
65994       delete arg1;
65995     } catch (std::out_of_range& e) {
65996       {
65997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65998       };
65999     } catch (std::exception& e) {
66000       {
66001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66002       };
66003     } catch (...) {
66004       {
66005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66006       };
66007     }
66008   }
66009 }
66010
66011
66012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66013   void * jresult ;
66014   Dali::Toolkit::ImageView *result = 0 ;
66015
66016   {
66017     try {
66018       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66019     } catch (std::out_of_range& e) {
66020       {
66021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66022       };
66023     } catch (std::exception& e) {
66024       {
66025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66026       };
66027     } catch (...) {
66028       {
66029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66030       };
66031     }
66032   }
66033   jresult = (void *)result;
66034   return jresult;
66035 }
66036
66037
66038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66039   void * jresult ;
66040   Dali::Toolkit::ImageView result;
66041
66042   {
66043     try {
66044       result = Dali::Toolkit::ImageView::New();
66045     } catch (std::out_of_range& e) {
66046       {
66047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66048       };
66049     } catch (std::exception& e) {
66050       {
66051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66052       };
66053     } catch (...) {
66054       {
66055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66056       };
66057     }
66058   }
66059   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66060   return jresult;
66061 }
66062
66063
66064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66065   void * jresult ;
66066   Dali::Image arg1 ;
66067   Dali::Image *argp1 ;
66068   Dali::Toolkit::ImageView result;
66069
66070   argp1 = (Dali::Image *)jarg1;
66071   if (!argp1) {
66072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66073     return 0;
66074   }
66075   arg1 = *argp1;
66076   {
66077     try {
66078       result = Dali::Toolkit::ImageView::New(arg1);
66079     } catch (std::out_of_range& e) {
66080       {
66081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (std::exception& e) {
66084       {
66085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66086       };
66087     } catch (...) {
66088       {
66089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66090       };
66091     }
66092   }
66093   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66099   void * jresult ;
66100   std::string *arg1 = 0 ;
66101   Dali::Toolkit::ImageView result;
66102
66103   if (!jarg1) {
66104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66105     return 0;
66106   }
66107   std::string arg1_str(jarg1);
66108   arg1 = &arg1_str;
66109   {
66110     try {
66111       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66112     } catch (std::out_of_range& e) {
66113       {
66114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (std::exception& e) {
66117       {
66118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66119       };
66120     } catch (...) {
66121       {
66122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66123       };
66124     }
66125   }
66126   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66127
66128   //argout typemap for const std::string&
66129
66130   return jresult;
66131 }
66132
66133
66134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66135   void * jresult ;
66136   std::string *arg1 = 0 ;
66137   Dali::ImageDimensions arg2 ;
66138   Dali::ImageDimensions *argp2 ;
66139   Dali::Toolkit::ImageView result;
66140
66141   if (!jarg1) {
66142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66143     return 0;
66144   }
66145   std::string arg1_str(jarg1);
66146   arg1 = &arg1_str;
66147   argp2 = (Dali::ImageDimensions *)jarg2;
66148   if (!argp2) {
66149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66150     return 0;
66151   }
66152   arg2 = *argp2;
66153   {
66154     try {
66155       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66156     } catch (std::out_of_range& e) {
66157       {
66158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66159       };
66160     } catch (std::exception& e) {
66161       {
66162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66163       };
66164     } catch (...) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66167       };
66168     }
66169   }
66170   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66171
66172   //argout typemap for const std::string&
66173
66174   return jresult;
66175 }
66176
66177
66178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66179   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66180
66181   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66182   {
66183     try {
66184       delete arg1;
66185     } catch (std::out_of_range& e) {
66186       {
66187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66188       };
66189     } catch (std::exception& e) {
66190       {
66191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66192       };
66193     } catch (...) {
66194       {
66195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66196       };
66197     }
66198   }
66199 }
66200
66201
66202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66203   void * jresult ;
66204   Dali::Toolkit::ImageView *arg1 = 0 ;
66205   Dali::Toolkit::ImageView *result = 0 ;
66206
66207   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66208   if (!arg1) {
66209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66210     return 0;
66211   }
66212   {
66213     try {
66214       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (...) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66226       };
66227     }
66228   }
66229   jresult = (void *)result;
66230   return jresult;
66231 }
66232
66233
66234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66235   void * jresult ;
66236   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66237   Dali::Toolkit::ImageView *arg2 = 0 ;
66238   Dali::Toolkit::ImageView *result = 0 ;
66239
66240   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66241   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66242   if (!arg2) {
66243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66244     return 0;
66245   }
66246   {
66247     try {
66248       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66249     } catch (std::out_of_range& e) {
66250       {
66251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66252       };
66253     } catch (std::exception& e) {
66254       {
66255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66256       };
66257     } catch (...) {
66258       {
66259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66260       };
66261     }
66262   }
66263   jresult = (void *)result;
66264   return jresult;
66265 }
66266
66267
66268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66269   void * jresult ;
66270   Dali::BaseHandle arg1 ;
66271   Dali::BaseHandle *argp1 ;
66272   Dali::Toolkit::ImageView result;
66273
66274   argp1 = (Dali::BaseHandle *)jarg1;
66275   if (!argp1) {
66276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66277     return 0;
66278   }
66279   arg1 = *argp1;
66280   {
66281     try {
66282       result = Dali::Toolkit::ImageView::DownCast(arg1);
66283     } catch (std::out_of_range& e) {
66284       {
66285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66286       };
66287     } catch (std::exception& e) {
66288       {
66289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66294       };
66295     }
66296   }
66297   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66298   return jresult;
66299 }
66300
66301
66302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66303   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66304   Dali::Image arg2 ;
66305   Dali::Image *argp2 ;
66306
66307   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66308   argp2 = (Dali::Image *)jarg2;
66309   if (!argp2) {
66310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66311     return ;
66312   }
66313   arg2 = *argp2;
66314   {
66315     try {
66316       (arg1)->SetImage(arg2);
66317     } catch (std::out_of_range& e) {
66318       {
66319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66320       };
66321     } catch (std::exception& e) {
66322       {
66323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66324       };
66325     } catch (...) {
66326       {
66327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66328       };
66329     }
66330   }
66331 }
66332
66333
66334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66335   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66336   std::string *arg2 = 0 ;
66337
66338   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66339   if (!jarg2) {
66340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66341     return ;
66342   }
66343   std::string arg2_str(jarg2);
66344   arg2 = &arg2_str;
66345   {
66346     try {
66347       (arg1)->SetImage((std::string const &)*arg2);
66348     } catch (std::out_of_range& e) {
66349       {
66350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66351       };
66352     } catch (std::exception& e) {
66353       {
66354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66355       };
66356     } catch (...) {
66357       {
66358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66359       };
66360     }
66361   }
66362
66363   //argout typemap for const std::string&
66364
66365 }
66366
66367
66368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66369   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66370   std::string *arg2 = 0 ;
66371   Dali::ImageDimensions arg3 ;
66372   Dali::ImageDimensions *argp3 ;
66373
66374   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66375   if (!jarg2) {
66376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66377     return ;
66378   }
66379   std::string arg2_str(jarg2);
66380   arg2 = &arg2_str;
66381   argp3 = (Dali::ImageDimensions *)jarg3;
66382   if (!argp3) {
66383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66384     return ;
66385   }
66386   arg3 = *argp3;
66387   {
66388     try {
66389       (arg1)->SetImage((std::string const &)*arg2,arg3);
66390     } catch (std::out_of_range& e) {
66391       {
66392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66393       };
66394     } catch (std::exception& e) {
66395       {
66396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66397       };
66398     } catch (...) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66401       };
66402     }
66403   }
66404
66405   //argout typemap for const std::string&
66406
66407 }
66408
66409
66410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66411   void * jresult ;
66412   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66413   Dali::Image result;
66414
66415   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66416   {
66417     try {
66418       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66419     } catch (std::out_of_range& e) {
66420       {
66421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66422       };
66423     } catch (std::exception& e) {
66424       {
66425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66426       };
66427     } catch (...) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66430       };
66431     }
66432   }
66433   jresult = new Dali::Image((const Dali::Image &)result);
66434   return jresult;
66435 }
66436
66437
66438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66439   int jresult ;
66440   int result;
66441
66442   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66443   jresult = (int)result;
66444   return jresult;
66445 }
66446
66447
66448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66449   int jresult ;
66450   int result;
66451
66452   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66453   jresult = (int)result;
66454   return jresult;
66455 }
66456
66457
66458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66459   int jresult ;
66460   int result;
66461
66462   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66463   jresult = (int)result;
66464   return jresult;
66465 }
66466
66467
66468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66469   int jresult ;
66470   int result;
66471
66472   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66473   jresult = (int)result;
66474   return jresult;
66475 }
66476
66477
66478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66479   int jresult ;
66480   int result;
66481
66482   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66483   jresult = (int)result;
66484   return jresult;
66485 }
66486
66487
66488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66489   int jresult ;
66490   int result;
66491
66492   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66493   jresult = (int)result;
66494   return jresult;
66495 }
66496
66497
66498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66499   int jresult ;
66500   int result;
66501
66502   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66503   jresult = (int)result;
66504   return jresult;
66505 }
66506
66507
66508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66509   int jresult ;
66510   int result;
66511
66512   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66513   jresult = (int)result;
66514   return jresult;
66515 }
66516
66517
66518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66519   void * jresult ;
66520   Dali::Toolkit::Model3dView::Property *result = 0 ;
66521
66522   {
66523     try {
66524       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66525     } catch (std::out_of_range& e) {
66526       {
66527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66528       };
66529     } catch (std::exception& e) {
66530       {
66531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66532       };
66533     } catch (...) {
66534       {
66535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66536       };
66537     }
66538   }
66539   jresult = (void *)result;
66540   return jresult;
66541 }
66542
66543
66544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66545   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66546
66547   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66548   {
66549     try {
66550       delete arg1;
66551     } catch (std::out_of_range& e) {
66552       {
66553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66554       };
66555     } catch (std::exception& e) {
66556       {
66557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66558       };
66559     } catch (...) {
66560       {
66561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66562       };
66563     }
66564   }
66565 }
66566
66567
66568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66569   void * jresult ;
66570   Dali::Toolkit::Model3dView result;
66571
66572   {
66573     try {
66574       result = Dali::Toolkit::Model3dView::New();
66575     } catch (std::out_of_range& e) {
66576       {
66577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66578       };
66579     } catch (std::exception& e) {
66580       {
66581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66582       };
66583     } catch (...) {
66584       {
66585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66586       };
66587     }
66588   }
66589   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66590   return jresult;
66591 }
66592
66593
66594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66595   void * jresult ;
66596   std::string *arg1 = 0 ;
66597   std::string *arg2 = 0 ;
66598   std::string *arg3 = 0 ;
66599   Dali::Toolkit::Model3dView result;
66600
66601   if (!jarg1) {
66602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66603     return 0;
66604   }
66605   std::string arg1_str(jarg1);
66606   arg1 = &arg1_str;
66607   if (!jarg2) {
66608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66609     return 0;
66610   }
66611   std::string arg2_str(jarg2);
66612   arg2 = &arg2_str;
66613   if (!jarg3) {
66614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66615     return 0;
66616   }
66617   std::string arg3_str(jarg3);
66618   arg3 = &arg3_str;
66619   {
66620     try {
66621       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66622     } catch (std::out_of_range& e) {
66623       {
66624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66625       };
66626     } catch (std::exception& e) {
66627       {
66628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66629       };
66630     } catch (...) {
66631       {
66632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66633       };
66634     }
66635   }
66636   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66637
66638   //argout typemap for const std::string&
66639
66640
66641   //argout typemap for const std::string&
66642
66643
66644   //argout typemap for const std::string&
66645
66646   return jresult;
66647 }
66648
66649
66650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66651   void * jresult ;
66652   Dali::Toolkit::Model3dView *result = 0 ;
66653
66654   {
66655     try {
66656       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66657     } catch (std::out_of_range& e) {
66658       {
66659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66660       };
66661     } catch (std::exception& e) {
66662       {
66663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66664       };
66665     } catch (...) {
66666       {
66667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66668       };
66669     }
66670   }
66671   jresult = (void *)result;
66672   return jresult;
66673 }
66674
66675
66676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66677   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66678
66679   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66680   {
66681     try {
66682       delete arg1;
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66690       };
66691     } catch (...) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66694       };
66695     }
66696   }
66697 }
66698
66699
66700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66701   void * jresult ;
66702   Dali::Toolkit::Model3dView *arg1 = 0 ;
66703   Dali::Toolkit::Model3dView *result = 0 ;
66704
66705   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66706   if (!arg1) {
66707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66708     return 0;
66709   }
66710   {
66711     try {
66712       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66713     } catch (std::out_of_range& e) {
66714       {
66715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66716       };
66717     } catch (std::exception& e) {
66718       {
66719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66720       };
66721     } catch (...) {
66722       {
66723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66724       };
66725     }
66726   }
66727   jresult = (void *)result;
66728   return jresult;
66729 }
66730
66731
66732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66733   void * jresult ;
66734   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66735   Dali::Toolkit::Model3dView *arg2 = 0 ;
66736   Dali::Toolkit::Model3dView *result = 0 ;
66737
66738   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66739   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66740   if (!arg2) {
66741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66742     return 0;
66743   }
66744   {
66745     try {
66746       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66747     } catch (std::out_of_range& e) {
66748       {
66749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66750       };
66751     } catch (std::exception& e) {
66752       {
66753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66754       };
66755     } catch (...) {
66756       {
66757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66758       };
66759     }
66760   }
66761   jresult = (void *)result;
66762   return jresult;
66763 }
66764
66765
66766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66767   void * jresult ;
66768   Dali::BaseHandle arg1 ;
66769   Dali::BaseHandle *argp1 ;
66770   Dali::Toolkit::Model3dView result;
66771
66772   argp1 = (Dali::BaseHandle *)jarg1;
66773   if (!argp1) {
66774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66775     return 0;
66776   }
66777   arg1 = *argp1;
66778   {
66779     try {
66780       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66781     } catch (std::out_of_range& e) {
66782       {
66783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66784       };
66785     } catch (std::exception& e) {
66786       {
66787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66788       };
66789     } catch (...) {
66790       {
66791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66792       };
66793     }
66794   }
66795   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66796   return jresult;
66797 }
66798
66799
66800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66801   int jresult ;
66802   int result;
66803
66804   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66805   jresult = (int)result;
66806   return jresult;
66807 }
66808
66809
66810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66811   int jresult ;
66812   int result;
66813
66814   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66815   jresult = (int)result;
66816   return jresult;
66817 }
66818
66819
66820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66821   int jresult ;
66822   int result;
66823
66824   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66825   jresult = (int)result;
66826   return jresult;
66827 }
66828
66829
66830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66831   int jresult ;
66832   int result;
66833
66834   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66835   jresult = (int)result;
66836   return jresult;
66837 }
66838
66839
66840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66841   int jresult ;
66842   int result;
66843
66844   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66845   jresult = (int)result;
66846   return jresult;
66847 }
66848
66849
66850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66851   int jresult ;
66852   int result;
66853
66854   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66855   jresult = (int)result;
66856   return jresult;
66857 }
66858
66859
66860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66861   int jresult ;
66862   int result;
66863
66864   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66865   jresult = (int)result;
66866   return jresult;
66867 }
66868
66869
66870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66871   int jresult ;
66872   int result;
66873
66874   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66875   jresult = (int)result;
66876   return jresult;
66877 }
66878
66879
66880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66881   int jresult ;
66882   int result;
66883
66884   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66885   jresult = (int)result;
66886   return jresult;
66887 }
66888
66889
66890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66891   void * jresult ;
66892   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66893
66894   {
66895     try {
66896       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66897     } catch (std::out_of_range& e) {
66898       {
66899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66900       };
66901     } catch (std::exception& e) {
66902       {
66903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66904       };
66905     } catch (...) {
66906       {
66907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66908       };
66909     }
66910   }
66911   jresult = (void *)result;
66912   return jresult;
66913 }
66914
66915
66916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66917   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66918
66919   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66920   {
66921     try {
66922       delete arg1;
66923     } catch (std::out_of_range& e) {
66924       {
66925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (std::exception& e) {
66928       {
66929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66930       };
66931     } catch (...) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66934       };
66935     }
66936   }
66937 }
66938
66939
66940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66941   void * jresult ;
66942   Dali::Toolkit::ScrollBar *result = 0 ;
66943
66944   {
66945     try {
66946       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66947     } catch (std::out_of_range& e) {
66948       {
66949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66950       };
66951     } catch (std::exception& e) {
66952       {
66953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66954       };
66955     } catch (...) {
66956       {
66957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66958       };
66959     }
66960   }
66961   jresult = (void *)result;
66962   return jresult;
66963 }
66964
66965
66966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66967   void * jresult ;
66968   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66969   Dali::Toolkit::ScrollBar *result = 0 ;
66970
66971   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66972   if (!arg1) {
66973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66974     return 0;
66975   }
66976   {
66977     try {
66978       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66979     } catch (std::out_of_range& e) {
66980       {
66981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66982       };
66983     } catch (std::exception& e) {
66984       {
66985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66986       };
66987     } catch (...) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66990       };
66991     }
66992   }
66993   jresult = (void *)result;
66994   return jresult;
66995 }
66996
66997
66998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
66999   void * jresult ;
67000   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67001   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67002   Dali::Toolkit::ScrollBar *result = 0 ;
67003
67004   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67005   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67006   if (!arg2) {
67007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67008     return 0;
67009   }
67010   {
67011     try {
67012       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67013     } catch (std::out_of_range& e) {
67014       {
67015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67016       };
67017     } catch (std::exception& e) {
67018       {
67019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67020       };
67021     } catch (...) {
67022       {
67023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67024       };
67025     }
67026   }
67027   jresult = (void *)result;
67028   return jresult;
67029 }
67030
67031
67032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67033   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67034
67035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67036   {
67037     try {
67038       delete arg1;
67039     } catch (std::out_of_range& e) {
67040       {
67041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67042       };
67043     } catch (std::exception& e) {
67044       {
67045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67046       };
67047     } catch (...) {
67048       {
67049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67050       };
67051     }
67052   }
67053 }
67054
67055
67056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67057   void * jresult ;
67058   Dali::Toolkit::ScrollBar::Direction arg1 ;
67059   Dali::Toolkit::ScrollBar result;
67060
67061   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67062   {
67063     try {
67064       result = Dali::Toolkit::ScrollBar::New(arg1);
67065     } catch (std::out_of_range& e) {
67066       {
67067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67068       };
67069     } catch (std::exception& e) {
67070       {
67071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67072       };
67073     } catch (...) {
67074       {
67075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67076       };
67077     }
67078   }
67079   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67080   return jresult;
67081 }
67082
67083
67084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67085   void * jresult ;
67086   Dali::Toolkit::ScrollBar result;
67087
67088   {
67089     try {
67090       result = Dali::Toolkit::ScrollBar::New();
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67098       };
67099     } catch (...) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67102       };
67103     }
67104   }
67105   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67106   return jresult;
67107 }
67108
67109
67110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67111   void * jresult ;
67112   Dali::BaseHandle arg1 ;
67113   Dali::BaseHandle *argp1 ;
67114   Dali::Toolkit::ScrollBar result;
67115
67116   argp1 = (Dali::BaseHandle *)jarg1;
67117   if (!argp1) {
67118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67119     return 0;
67120   }
67121   arg1 = *argp1;
67122   {
67123     try {
67124       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67125     } catch (std::out_of_range& e) {
67126       {
67127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67128       };
67129     } catch (std::exception& e) {
67130       {
67131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67132       };
67133     } catch (...) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67136       };
67137     }
67138   }
67139   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67140   return jresult;
67141 }
67142
67143
67144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67145   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67146   Dali::Handle arg2 ;
67147   Dali::Property::Index arg3 ;
67148   Dali::Property::Index arg4 ;
67149   Dali::Property::Index arg5 ;
67150   Dali::Property::Index arg6 ;
67151   Dali::Handle *argp2 ;
67152
67153   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67154   argp2 = (Dali::Handle *)jarg2;
67155   if (!argp2) {
67156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67157     return ;
67158   }
67159   arg2 = *argp2;
67160   arg3 = (Dali::Property::Index)jarg3;
67161   arg4 = (Dali::Property::Index)jarg4;
67162   arg5 = (Dali::Property::Index)jarg5;
67163   arg6 = (Dali::Property::Index)jarg6;
67164   {
67165     try {
67166       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67167     } catch (std::out_of_range& e) {
67168       {
67169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67170       };
67171     } catch (std::exception& e) {
67172       {
67173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67174       };
67175     } catch (...) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67178       };
67179     }
67180   }
67181 }
67182
67183
67184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67185   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67186   Dali::Actor arg2 ;
67187   Dali::Actor *argp2 ;
67188
67189   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67190   argp2 = (Dali::Actor *)jarg2;
67191   if (!argp2) {
67192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67193     return ;
67194   }
67195   arg2 = *argp2;
67196   {
67197     try {
67198       (arg1)->SetScrollIndicator(arg2);
67199     } catch (std::out_of_range& e) {
67200       {
67201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67202       };
67203     } catch (std::exception& e) {
67204       {
67205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67206       };
67207     } catch (...) {
67208       {
67209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67210       };
67211     }
67212   }
67213 }
67214
67215
67216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67217   void * jresult ;
67218   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67219   Dali::Actor result;
67220
67221   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67222   {
67223     try {
67224       result = (arg1)->GetScrollIndicator();
67225     } catch (std::out_of_range& e) {
67226       {
67227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67228       };
67229     } catch (std::exception& e) {
67230       {
67231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67232       };
67233     } catch (...) {
67234       {
67235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67236       };
67237     }
67238   }
67239   jresult = new Dali::Actor((const Dali::Actor &)result);
67240   return jresult;
67241 }
67242
67243
67244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67245   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67246   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67247
67248   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67249   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67250   if (!arg2) {
67251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67252     return ;
67253   }
67254   {
67255     try {
67256       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67257     } catch (std::out_of_range& e) {
67258       {
67259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67260       };
67261     } catch (std::exception& e) {
67262       {
67263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67264       };
67265     } catch (...) {
67266       {
67267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67268       };
67269     }
67270   }
67271 }
67272
67273
67274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67275   void * jresult ;
67276   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67277   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67278
67279   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67280   {
67281     try {
67282       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67283     } catch (std::out_of_range& e) {
67284       {
67285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (std::exception& e) {
67288       {
67289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67294       };
67295     }
67296   }
67297   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67303   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67304   Dali::Toolkit::ScrollBar::Direction arg2 ;
67305
67306   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67307   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67308   {
67309     try {
67310       (arg1)->SetScrollDirection(arg2);
67311     } catch (std::out_of_range& e) {
67312       {
67313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67314       };
67315     } catch (std::exception& e) {
67316       {
67317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67318       };
67319     } catch (...) {
67320       {
67321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67322       };
67323     }
67324   }
67325 }
67326
67327
67328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67329   int jresult ;
67330   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67331   Dali::Toolkit::ScrollBar::Direction result;
67332
67333   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67334   {
67335     try {
67336       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67337     } catch (std::out_of_range& e) {
67338       {
67339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67340       };
67341     } catch (std::exception& e) {
67342       {
67343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67344       };
67345     } catch (...) {
67346       {
67347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67348       };
67349     }
67350   }
67351   jresult = (int)result;
67352   return jresult;
67353 }
67354
67355
67356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67357   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67358   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67359
67360   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67361   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67362   {
67363     try {
67364       (arg1)->SetIndicatorHeightPolicy(arg2);
67365     } catch (std::out_of_range& e) {
67366       {
67367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67368       };
67369     } catch (std::exception& e) {
67370       {
67371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67372       };
67373     } catch (...) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67376       };
67377     }
67378   }
67379 }
67380
67381
67382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67383   int jresult ;
67384   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67385   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67386
67387   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67388   {
67389     try {
67390       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67391     } catch (std::out_of_range& e) {
67392       {
67393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67394       };
67395     } catch (std::exception& e) {
67396       {
67397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67398       };
67399     } catch (...) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67402       };
67403     }
67404   }
67405   jresult = (int)result;
67406   return jresult;
67407 }
67408
67409
67410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67411   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67412   float arg2 ;
67413
67414   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67415   arg2 = (float)jarg2;
67416   {
67417     try {
67418       (arg1)->SetIndicatorFixedHeight(arg2);
67419     } catch (std::out_of_range& e) {
67420       {
67421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67422       };
67423     } catch (std::exception& e) {
67424       {
67425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67430       };
67431     }
67432   }
67433 }
67434
67435
67436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67437   float jresult ;
67438   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67439   float result;
67440
67441   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67442   {
67443     try {
67444       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67445     } catch (std::out_of_range& e) {
67446       {
67447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67448       };
67449     } catch (std::exception& e) {
67450       {
67451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67452       };
67453     } catch (...) {
67454       {
67455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67456       };
67457     }
67458   }
67459   jresult = result;
67460   return jresult;
67461 }
67462
67463
67464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67465   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67466   float arg2 ;
67467
67468   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67469   arg2 = (float)jarg2;
67470   {
67471     try {
67472       (arg1)->SetIndicatorShowDuration(arg2);
67473     } catch (std::out_of_range& e) {
67474       {
67475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67476       };
67477     } catch (std::exception& e) {
67478       {
67479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67480       };
67481     } catch (...) {
67482       {
67483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67484       };
67485     }
67486   }
67487 }
67488
67489
67490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67491   float jresult ;
67492   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67493   float result;
67494
67495   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67496   {
67497     try {
67498       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67499     } catch (std::out_of_range& e) {
67500       {
67501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (std::exception& e) {
67504       {
67505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67506       };
67507     } catch (...) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67510       };
67511     }
67512   }
67513   jresult = result;
67514   return jresult;
67515 }
67516
67517
67518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67519   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67520   float arg2 ;
67521
67522   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67523   arg2 = (float)jarg2;
67524   {
67525     try {
67526       (arg1)->SetIndicatorHideDuration(arg2);
67527     } catch (std::out_of_range& e) {
67528       {
67529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67530       };
67531     } catch (std::exception& e) {
67532       {
67533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67534       };
67535     } catch (...) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67538       };
67539     }
67540   }
67541 }
67542
67543
67544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67545   float jresult ;
67546   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67547   float result;
67548
67549   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67550   {
67551     try {
67552       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67553     } catch (std::out_of_range& e) {
67554       {
67555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67556       };
67557     } catch (std::exception& e) {
67558       {
67559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67560       };
67561     } catch (...) {
67562       {
67563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67564       };
67565     }
67566   }
67567   jresult = result;
67568   return jresult;
67569 }
67570
67571
67572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67573   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67574
67575   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67576   {
67577     try {
67578       (arg1)->ShowIndicator();
67579     } catch (std::out_of_range& e) {
67580       {
67581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67582       };
67583     } catch (std::exception& e) {
67584       {
67585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67586       };
67587     } catch (...) {
67588       {
67589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67590       };
67591     }
67592   }
67593 }
67594
67595
67596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67597   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67598
67599   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67600   {
67601     try {
67602       (arg1)->HideIndicator();
67603     } catch (std::out_of_range& e) {
67604       {
67605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67606       };
67607     } catch (std::exception& e) {
67608       {
67609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67610       };
67611     } catch (...) {
67612       {
67613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67614       };
67615     }
67616   }
67617 }
67618
67619
67620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67621   void * jresult ;
67622   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67623   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67624
67625   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67626   {
67627     try {
67628       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67629     } catch (std::out_of_range& e) {
67630       {
67631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67632       };
67633     } catch (std::exception& e) {
67634       {
67635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67636       };
67637     } catch (...) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67640       };
67641     }
67642   }
67643   jresult = (void *)result;
67644   return jresult;
67645 }
67646
67647
67648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67649   void * jresult ;
67650   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67651   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67652
67653   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67654   {
67655     try {
67656       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67657     } catch (std::out_of_range& e) {
67658       {
67659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67660       };
67661     } catch (std::exception& e) {
67662       {
67663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (...) {
67666       {
67667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67668       };
67669     }
67670   }
67671   jresult = (void *)result;
67672   return jresult;
67673 }
67674
67675
67676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67677   int jresult ;
67678   int result;
67679
67680   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67681   jresult = (int)result;
67682   return jresult;
67683 }
67684
67685
67686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67687   int jresult ;
67688   int result;
67689
67690   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67691   jresult = (int)result;
67692   return jresult;
67693 }
67694
67695
67696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67697   int jresult ;
67698   int result;
67699
67700   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67701   jresult = (int)result;
67702   return jresult;
67703 }
67704
67705
67706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67707   int jresult ;
67708   int result;
67709
67710   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67711   jresult = (int)result;
67712   return jresult;
67713 }
67714
67715
67716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67717   int jresult ;
67718   int result;
67719
67720   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67721   jresult = (int)result;
67722   return jresult;
67723 }
67724
67725
67726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67727   int jresult ;
67728   int result;
67729
67730   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67731   jresult = (int)result;
67732   return jresult;
67733 }
67734
67735
67736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67737   int jresult ;
67738   int result;
67739
67740   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67741   jresult = (int)result;
67742   return jresult;
67743 }
67744
67745
67746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67747   int jresult ;
67748   int result;
67749
67750   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67751   jresult = (int)result;
67752   return jresult;
67753 }
67754
67755
67756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67757   int jresult ;
67758   int result;
67759
67760   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67761   jresult = (int)result;
67762   return jresult;
67763 }
67764
67765
67766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67767   int jresult ;
67768   int result;
67769
67770   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67771   jresult = (int)result;
67772   return jresult;
67773 }
67774
67775
67776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67777   int jresult ;
67778   int result;
67779
67780   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67781   jresult = (int)result;
67782   return jresult;
67783 }
67784
67785
67786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67787   int jresult ;
67788   int result;
67789
67790   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67791   jresult = (int)result;
67792   return jresult;
67793 }
67794
67795
67796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67797   int jresult ;
67798   int result;
67799
67800   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67801   jresult = (int)result;
67802   return jresult;
67803 }
67804
67805
67806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67807   int jresult ;
67808   int result;
67809
67810   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67811   jresult = (int)result;
67812   return jresult;
67813 }
67814
67815
67816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67817   void * jresult ;
67818   Dali::Toolkit::Scrollable::Property *result = 0 ;
67819
67820   {
67821     try {
67822       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67823     } catch (std::out_of_range& e) {
67824       {
67825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67826       };
67827     } catch (std::exception& e) {
67828       {
67829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67830       };
67831     } catch (...) {
67832       {
67833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67834       };
67835     }
67836   }
67837   jresult = (void *)result;
67838   return jresult;
67839 }
67840
67841
67842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67843   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67844
67845   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67846   {
67847     try {
67848       delete arg1;
67849     } catch (std::out_of_range& e) {
67850       {
67851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67852       };
67853     } catch (std::exception& e) {
67854       {
67855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67856       };
67857     } catch (...) {
67858       {
67859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67860       };
67861     }
67862   }
67863 }
67864
67865
67866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67867   void * jresult ;
67868   Dali::Toolkit::Scrollable *result = 0 ;
67869
67870   {
67871     try {
67872       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67873     } catch (std::out_of_range& e) {
67874       {
67875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67876       };
67877     } catch (std::exception& e) {
67878       {
67879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67880       };
67881     } catch (...) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67884       };
67885     }
67886   }
67887   jresult = (void *)result;
67888   return jresult;
67889 }
67890
67891
67892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67893   void * jresult ;
67894   Dali::Toolkit::Scrollable *arg1 = 0 ;
67895   Dali::Toolkit::Scrollable *result = 0 ;
67896
67897   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67898   if (!arg1) {
67899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67900     return 0;
67901   }
67902   {
67903     try {
67904       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67905     } catch (std::out_of_range& e) {
67906       {
67907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67908       };
67909     } catch (std::exception& e) {
67910       {
67911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67912       };
67913     } catch (...) {
67914       {
67915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67916       };
67917     }
67918   }
67919   jresult = (void *)result;
67920   return jresult;
67921 }
67922
67923
67924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67925   void * jresult ;
67926   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67927   Dali::Toolkit::Scrollable *arg2 = 0 ;
67928   Dali::Toolkit::Scrollable *result = 0 ;
67929
67930   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67931   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67932   if (!arg2) {
67933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67934     return 0;
67935   }
67936   {
67937     try {
67938       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67939     } catch (std::out_of_range& e) {
67940       {
67941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67942       };
67943     } catch (std::exception& e) {
67944       {
67945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67946       };
67947     } catch (...) {
67948       {
67949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67950       };
67951     }
67952   }
67953   jresult = (void *)result;
67954   return jresult;
67955 }
67956
67957
67958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67959   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67960
67961   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67962   {
67963     try {
67964       delete arg1;
67965     } catch (std::out_of_range& e) {
67966       {
67967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67968       };
67969     } catch (std::exception& e) {
67970       {
67971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67972       };
67973     } catch (...) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67976       };
67977     }
67978   }
67979 }
67980
67981
67982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67983   void * jresult ;
67984   Dali::BaseHandle arg1 ;
67985   Dali::BaseHandle *argp1 ;
67986   Dali::Toolkit::Scrollable result;
67987
67988   argp1 = (Dali::BaseHandle *)jarg1;
67989   if (!argp1) {
67990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67991     return 0;
67992   }
67993   arg1 = *argp1;
67994   {
67995     try {
67996       result = Dali::Toolkit::Scrollable::DownCast(arg1);
67997     } catch (std::out_of_range& e) {
67998       {
67999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68000       };
68001     } catch (std::exception& e) {
68002       {
68003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68004       };
68005     } catch (...) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68008       };
68009     }
68010   }
68011   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68012   return jresult;
68013 }
68014
68015
68016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68017   unsigned int jresult ;
68018   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68019   bool result;
68020
68021   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68022   {
68023     try {
68024       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68025     } catch (std::out_of_range& e) {
68026       {
68027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68028       };
68029     } catch (std::exception& e) {
68030       {
68031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68032       };
68033     } catch (...) {
68034       {
68035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68036       };
68037     }
68038   }
68039   jresult = result;
68040   return jresult;
68041 }
68042
68043
68044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68045   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68046   bool arg2 ;
68047
68048   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68049   arg2 = jarg2 ? true : false;
68050   {
68051     try {
68052       (arg1)->SetOvershootEnabled(arg2);
68053     } catch (std::out_of_range& e) {
68054       {
68055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68056       };
68057     } catch (std::exception& e) {
68058       {
68059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68060       };
68061     } catch (...) {
68062       {
68063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68064       };
68065     }
68066   }
68067 }
68068
68069
68070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68071   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68072   Dali::Vector4 *arg2 = 0 ;
68073
68074   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68075   arg2 = (Dali::Vector4 *)jarg2;
68076   if (!arg2) {
68077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68078     return ;
68079   }
68080   {
68081     try {
68082       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68083     } catch (std::out_of_range& e) {
68084       {
68085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68086       };
68087     } catch (std::exception& e) {
68088       {
68089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68090       };
68091     } catch (...) {
68092       {
68093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68094       };
68095     }
68096   }
68097 }
68098
68099
68100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68101   void * jresult ;
68102   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68103   Dali::Vector4 result;
68104
68105   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68106   {
68107     try {
68108       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68109     } catch (std::out_of_range& e) {
68110       {
68111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68112       };
68113     } catch (std::exception& e) {
68114       {
68115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68116       };
68117     } catch (...) {
68118       {
68119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68120       };
68121     }
68122   }
68123   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68124   return jresult;
68125 }
68126
68127
68128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68129   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68130   float arg2 ;
68131
68132   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68133   arg2 = (float)jarg2;
68134   {
68135     try {
68136       (arg1)->SetOvershootAnimationSpeed(arg2);
68137     } catch (std::out_of_range& e) {
68138       {
68139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68140       };
68141     } catch (std::exception& e) {
68142       {
68143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68144       };
68145     } catch (...) {
68146       {
68147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68148       };
68149     }
68150   }
68151 }
68152
68153
68154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68155   float jresult ;
68156   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68157   float result;
68158
68159   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68160   {
68161     try {
68162       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68163     } catch (std::out_of_range& e) {
68164       {
68165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68166       };
68167     } catch (std::exception& e) {
68168       {
68169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68170       };
68171     } catch (...) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68174       };
68175     }
68176   }
68177   jresult = result;
68178   return jresult;
68179 }
68180
68181
68182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68183   void * jresult ;
68184   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68185   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68186
68187   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68188   {
68189     try {
68190       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68191     } catch (std::out_of_range& e) {
68192       {
68193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68194       };
68195     } catch (std::exception& e) {
68196       {
68197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68198       };
68199     } catch (...) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68202       };
68203     }
68204   }
68205   jresult = (void *)result;
68206   return jresult;
68207 }
68208
68209
68210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68211   void * jresult ;
68212   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68213   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68214
68215   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68216   {
68217     try {
68218       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68219     } catch (std::out_of_range& e) {
68220       {
68221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68222       };
68223     } catch (std::exception& e) {
68224       {
68225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68226       };
68227     } catch (...) {
68228       {
68229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68230       };
68231     }
68232   }
68233   jresult = (void *)result;
68234   return jresult;
68235 }
68236
68237
68238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68239   void * jresult ;
68240   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68241   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68242
68243   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68244   {
68245     try {
68246       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68254       };
68255     } catch (...) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68258       };
68259     }
68260   }
68261   jresult = (void *)result;
68262   return jresult;
68263 }
68264
68265
68266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68267   unsigned int jresult ;
68268   Dali::Toolkit::ControlOrientation::Type arg1 ;
68269   bool result;
68270
68271   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68272   {
68273     try {
68274       result = (bool)Dali::Toolkit::IsVertical(arg1);
68275     } catch (std::out_of_range& e) {
68276       {
68277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68278       };
68279     } catch (std::exception& e) {
68280       {
68281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68282       };
68283     } catch (...) {
68284       {
68285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68286       };
68287     }
68288   }
68289   jresult = result;
68290   return jresult;
68291 }
68292
68293
68294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68295   unsigned int jresult ;
68296   Dali::Toolkit::ControlOrientation::Type arg1 ;
68297   bool result;
68298
68299   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68300   {
68301     try {
68302       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68303     } catch (std::out_of_range& e) {
68304       {
68305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68306       };
68307     } catch (std::exception& e) {
68308       {
68309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (...) {
68312       {
68313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68314       };
68315     }
68316   }
68317   jresult = result;
68318   return jresult;
68319 }
68320
68321
68322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68323   void * jresult ;
68324   unsigned int arg1 ;
68325   unsigned int arg2 ;
68326   Dali::Toolkit::ItemRange *result = 0 ;
68327
68328   arg1 = (unsigned int)jarg1;
68329   arg2 = (unsigned int)jarg2;
68330   {
68331     try {
68332       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68333     } catch (std::out_of_range& e) {
68334       {
68335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68336       };
68337     } catch (std::exception& e) {
68338       {
68339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68340       };
68341     } catch (...) {
68342       {
68343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68344       };
68345     }
68346   }
68347   jresult = (void *)result;
68348   return jresult;
68349 }
68350
68351
68352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68353   void * jresult ;
68354   Dali::Toolkit::ItemRange *arg1 = 0 ;
68355   Dali::Toolkit::ItemRange *result = 0 ;
68356
68357   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68358   if (!arg1) {
68359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68360     return 0;
68361   }
68362   {
68363     try {
68364       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68365     } catch (std::out_of_range& e) {
68366       {
68367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68368       };
68369     } catch (std::exception& e) {
68370       {
68371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68372       };
68373     } catch (...) {
68374       {
68375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68376       };
68377     }
68378   }
68379   jresult = (void *)result;
68380   return jresult;
68381 }
68382
68383
68384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68385   void * jresult ;
68386   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68387   Dali::Toolkit::ItemRange *arg2 = 0 ;
68388   Dali::Toolkit::ItemRange *result = 0 ;
68389
68390   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68391   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68392   if (!arg2) {
68393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68394     return 0;
68395   }
68396   {
68397     try {
68398       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68399     } catch (std::out_of_range& e) {
68400       {
68401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68402       };
68403     } catch (std::exception& e) {
68404       {
68405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68406       };
68407     } catch (...) {
68408       {
68409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68410       };
68411     }
68412   }
68413   jresult = (void *)result;
68414   return jresult;
68415 }
68416
68417
68418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68419   unsigned int jresult ;
68420   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68421   unsigned int arg2 ;
68422   bool result;
68423
68424   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68425   arg2 = (unsigned int)jarg2;
68426   {
68427     try {
68428       result = (bool)(arg1)->Within(arg2);
68429     } catch (std::out_of_range& e) {
68430       {
68431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68432       };
68433     } catch (std::exception& e) {
68434       {
68435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68436       };
68437     } catch (...) {
68438       {
68439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68440       };
68441     }
68442   }
68443   jresult = result;
68444   return jresult;
68445 }
68446
68447
68448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68449   void * jresult ;
68450   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68451   Dali::Toolkit::ItemRange *arg2 = 0 ;
68452   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68453
68454   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68455   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68456   if (!arg2) {
68457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68458     return 0;
68459   }
68460   {
68461     try {
68462       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68463     } catch (std::out_of_range& e) {
68464       {
68465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68466       };
68467     } catch (std::exception& e) {
68468       {
68469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68470       };
68471     } catch (...) {
68472       {
68473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68474       };
68475     }
68476   }
68477   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68478   return jresult;
68479 }
68480
68481
68482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68483   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68484   unsigned int arg2 ;
68485
68486   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68487   arg2 = (unsigned int)jarg2;
68488   if (arg1) (arg1)->begin = arg2;
68489 }
68490
68491
68492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68493   unsigned int jresult ;
68494   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68495   unsigned int result;
68496
68497   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68498   result = (unsigned int) ((arg1)->begin);
68499   jresult = result;
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68505   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68506   unsigned int arg2 ;
68507
68508   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68509   arg2 = (unsigned int)jarg2;
68510   if (arg1) (arg1)->end = arg2;
68511 }
68512
68513
68514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68515   unsigned int jresult ;
68516   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68517   unsigned int result;
68518
68519   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68520   result = (unsigned int) ((arg1)->end);
68521   jresult = result;
68522   return jresult;
68523 }
68524
68525
68526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68527   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68528
68529   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68530   {
68531     try {
68532       delete arg1;
68533     } catch (std::out_of_range& e) {
68534       {
68535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68536       };
68537     } catch (std::exception& e) {
68538       {
68539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68540       };
68541     } catch (...) {
68542       {
68543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68544       };
68545     }
68546   }
68547 }
68548
68549
68550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68551   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68552
68553   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68554   {
68555     try {
68556       delete arg1;
68557     } catch (std::out_of_range& e) {
68558       {
68559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68560       };
68561     } catch (std::exception& e) {
68562       {
68563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68564       };
68565     } catch (...) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68568       };
68569     }
68570   }
68571 }
68572
68573
68574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68575   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68576   Dali::Toolkit::ControlOrientation::Type arg2 ;
68577
68578   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68579   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68580   {
68581     try {
68582       (arg1)->SetOrientation(arg2);
68583     } catch (std::out_of_range& e) {
68584       {
68585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68586       };
68587     } catch (std::exception& e) {
68588       {
68589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68590       };
68591     } catch (...) {
68592       {
68593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68594       };
68595     }
68596   }
68597 }
68598
68599
68600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68601   int jresult ;
68602   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68603   Dali::Toolkit::ControlOrientation::Type result;
68604
68605   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68606   {
68607     try {
68608       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68609     } catch (std::out_of_range& e) {
68610       {
68611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68612       };
68613     } catch (std::exception& e) {
68614       {
68615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68616       };
68617     } catch (...) {
68618       {
68619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68620       };
68621     }
68622   }
68623   jresult = (int)result;
68624   return jresult;
68625 }
68626
68627
68628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68629   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68630   Dali::Property::Map *arg2 = 0 ;
68631
68632   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68633   arg2 = (Dali::Property::Map *)jarg2;
68634   if (!arg2) {
68635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68636     return ;
68637   }
68638   {
68639     try {
68640       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68641     } catch (std::out_of_range& e) {
68642       {
68643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68644       };
68645     } catch (std::exception& e) {
68646       {
68647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68648       };
68649     } catch (...) {
68650       {
68651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68652       };
68653     }
68654   }
68655 }
68656
68657
68658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68659   void * jresult ;
68660   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68661   Dali::Property::Map result;
68662
68663   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68664   {
68665     try {
68666       result = (arg1)->GetLayoutProperties();
68667     } catch (std::out_of_range& e) {
68668       {
68669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68670       };
68671     } catch (std::exception& e) {
68672       {
68673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68678       };
68679     }
68680   }
68681   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68682   return jresult;
68683 }
68684
68685
68686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68688   unsigned int arg2 ;
68689   Dali::Vector3 *arg3 = 0 ;
68690   Dali::Vector3 *arg4 = 0 ;
68691
68692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68693   arg2 = (unsigned int)jarg2;
68694   arg3 = (Dali::Vector3 *)jarg3;
68695   if (!arg3) {
68696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68697     return ;
68698   }
68699   arg4 = (Dali::Vector3 *)jarg4;
68700   if (!arg4) {
68701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68702     return ;
68703   }
68704   {
68705     try {
68706       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68707     } catch (std::out_of_range& e) {
68708       {
68709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68710       };
68711     } catch (std::exception& e) {
68712       {
68713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68714       };
68715     } catch (...) {
68716       {
68717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68718       };
68719     }
68720   }
68721 }
68722
68723
68724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68725   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68726   Dali::Vector3 *arg2 = 0 ;
68727
68728   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68729   arg2 = (Dali::Vector3 *)jarg2;
68730   if (!arg2) {
68731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68732     return ;
68733   }
68734   {
68735     try {
68736       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68737     } catch (std::out_of_range& e) {
68738       {
68739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68740       };
68741     } catch (std::exception& e) {
68742       {
68743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68748       };
68749     }
68750   }
68751 }
68752
68753
68754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68755   float jresult ;
68756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68757   unsigned int arg2 ;
68758   Dali::Vector3 arg3 ;
68759   Dali::Vector3 *argp3 ;
68760   float result;
68761
68762   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68763   arg2 = (unsigned int)jarg2;
68764   argp3 = (Dali::Vector3 *)jarg3;
68765   if (!argp3) {
68766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68767     return 0;
68768   }
68769   arg3 = *argp3;
68770   {
68771     try {
68772       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68773     } catch (std::out_of_range& e) {
68774       {
68775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68776       };
68777     } catch (std::exception& e) {
68778       {
68779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68780       };
68781     } catch (...) {
68782       {
68783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68784       };
68785     }
68786   }
68787   jresult = result;
68788   return jresult;
68789 }
68790
68791
68792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68793   float jresult ;
68794   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68795   float arg2 ;
68796   float result;
68797
68798   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68799   arg2 = (float)jarg2;
68800   {
68801     try {
68802       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68803     } catch (std::out_of_range& e) {
68804       {
68805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (std::exception& e) {
68808       {
68809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68810       };
68811     } catch (...) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68814       };
68815     }
68816   }
68817   jresult = result;
68818   return jresult;
68819 }
68820
68821
68822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68823   float jresult ;
68824   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68825   unsigned int arg2 ;
68826   float result;
68827
68828   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68829   arg2 = (unsigned int)jarg2;
68830   {
68831     try {
68832       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68833     } catch (std::out_of_range& e) {
68834       {
68835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68836       };
68837     } catch (std::exception& e) {
68838       {
68839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68840       };
68841     } catch (...) {
68842       {
68843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68844       };
68845     }
68846   }
68847   jresult = result;
68848   return jresult;
68849 }
68850
68851
68852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68853   void * jresult ;
68854   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68855   float arg2 ;
68856   Dali::Vector3 arg3 ;
68857   Dali::Vector3 *argp3 ;
68858   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68859
68860   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68861   arg2 = (float)jarg2;
68862   argp3 = (Dali::Vector3 *)jarg3;
68863   if (!argp3) {
68864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68865     return 0;
68866   }
68867   arg3 = *argp3;
68868   {
68869     try {
68870       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68871     } catch (std::out_of_range& e) {
68872       {
68873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68874       };
68875     } catch (std::exception& e) {
68876       {
68877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68882       };
68883     }
68884   }
68885   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68886   return jresult;
68887 }
68888
68889
68890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68891   float jresult ;
68892   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68893   int arg2 ;
68894   float arg3 ;
68895   Dali::Vector3 *arg4 = 0 ;
68896   float result;
68897
68898   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68899   arg2 = (int)jarg2;
68900   arg3 = (float)jarg3;
68901   arg4 = (Dali::Vector3 *)jarg4;
68902   if (!arg4) {
68903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68904     return 0;
68905   }
68906   {
68907     try {
68908       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68909     } catch (std::out_of_range& e) {
68910       {
68911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68912       };
68913     } catch (std::exception& e) {
68914       {
68915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (...) {
68918       {
68919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68920       };
68921     }
68922   }
68923   jresult = result;
68924   return jresult;
68925 }
68926
68927
68928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68929   unsigned int jresult ;
68930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68931   Dali::Vector3 arg2 ;
68932   Dali::Vector3 *argp2 ;
68933   unsigned int result;
68934
68935   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68936   argp2 = (Dali::Vector3 *)jarg2;
68937   if (!argp2) {
68938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68939     return 0;
68940   }
68941   arg2 = *argp2;
68942   {
68943     try {
68944       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68952       };
68953     } catch (...) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68956       };
68957     }
68958   }
68959   jresult = result;
68960   return jresult;
68961 }
68962
68963
68964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68965   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68966   unsigned int arg2 ;
68967   Dali::Vector3 *arg3 = 0 ;
68968   Dali::Vector3 *arg4 = 0 ;
68969
68970   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68971   arg2 = (unsigned int)jarg2;
68972   arg3 = (Dali::Vector3 *)jarg3;
68973   if (!arg3) {
68974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68975     return ;
68976   }
68977   arg4 = (Dali::Vector3 *)jarg4;
68978   if (!arg4) {
68979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68980     return ;
68981   }
68982   {
68983     try {
68984       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68985     } catch (std::out_of_range& e) {
68986       {
68987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68988       };
68989     } catch (std::exception& e) {
68990       {
68991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68992       };
68993     } catch (...) {
68994       {
68995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68996       };
68997     }
68998   }
68999 }
69000
69001
69002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69003   void * jresult ;
69004   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69005   Dali::Degree result;
69006
69007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69008   {
69009     try {
69010       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69011     } catch (std::out_of_range& e) {
69012       {
69013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69014       };
69015     } catch (std::exception& e) {
69016       {
69017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69018       };
69019     } catch (...) {
69020       {
69021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69022       };
69023     }
69024   }
69025   jresult = new Dali::Degree((const Dali::Degree &)result);
69026   return jresult;
69027 }
69028
69029
69030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69031   float jresult ;
69032   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69033   float result;
69034
69035   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69036   {
69037     try {
69038       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69039     } catch (std::out_of_range& e) {
69040       {
69041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69042       };
69043     } catch (std::exception& e) {
69044       {
69045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69046       };
69047     } catch (...) {
69048       {
69049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69050       };
69051     }
69052   }
69053   jresult = result;
69054   return jresult;
69055 }
69056
69057
69058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69059   float jresult ;
69060   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69061   float result;
69062
69063   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69064   {
69065     try {
69066       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69067     } catch (std::out_of_range& e) {
69068       {
69069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69070       };
69071     } catch (std::exception& e) {
69072       {
69073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69074       };
69075     } catch (...) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69078       };
69079     }
69080   }
69081   jresult = result;
69082   return jresult;
69083 }
69084
69085
69086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69087   float jresult ;
69088   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69089   float result;
69090
69091   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69092   {
69093     try {
69094       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69095     } catch (std::out_of_range& e) {
69096       {
69097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (std::exception& e) {
69100       {
69101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69102       };
69103     } catch (...) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69106       };
69107     }
69108   }
69109   jresult = result;
69110   return jresult;
69111 }
69112
69113
69114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69115   int jresult ;
69116   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69117   int arg2 ;
69118   int arg3 ;
69119   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69120   bool arg5 ;
69121   int result;
69122
69123   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69124   arg2 = (int)jarg2;
69125   arg3 = (int)jarg3;
69126   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69127   arg5 = jarg5 ? true : false;
69128   {
69129     try {
69130       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69131     } catch (std::out_of_range& e) {
69132       {
69133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69134       };
69135     } catch (std::exception& e) {
69136       {
69137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69138       };
69139     } catch (...) {
69140       {
69141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69142       };
69143     }
69144   }
69145   jresult = result;
69146   return jresult;
69147 }
69148
69149
69150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69151   float jresult ;
69152   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69153   float result;
69154
69155   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69156   {
69157     try {
69158       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69159     } catch (std::out_of_range& e) {
69160       {
69161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69162       };
69163     } catch (std::exception& e) {
69164       {
69165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69166       };
69167     } catch (...) {
69168       {
69169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69170       };
69171     }
69172   }
69173   jresult = result;
69174   return jresult;
69175 }
69176
69177
69178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69179   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69180   Dali::Actor *arg2 = 0 ;
69181   int arg3 ;
69182   Dali::Vector3 *arg4 = 0 ;
69183   Dali::Actor *arg5 = 0 ;
69184
69185   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69186   arg2 = (Dali::Actor *)jarg2;
69187   if (!arg2) {
69188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69189     return ;
69190   }
69191   arg3 = (int)jarg3;
69192   arg4 = (Dali::Vector3 *)jarg4;
69193   if (!arg4) {
69194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69195     return ;
69196   }
69197   arg5 = (Dali::Actor *)jarg5;
69198   if (!arg5) {
69199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69200     return ;
69201   }
69202   {
69203     try {
69204       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69205     } catch (std::out_of_range& e) {
69206       {
69207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69208       };
69209     } catch (std::exception& e) {
69210       {
69211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69212       };
69213     } catch (...) {
69214       {
69215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69216       };
69217     }
69218   }
69219 }
69220
69221
69222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69223   void * jresult ;
69224   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69225   int arg2 ;
69226   float arg3 ;
69227   Dali::Vector3 *arg4 = 0 ;
69228   Dali::Vector3 result;
69229
69230   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69231   arg2 = (int)jarg2;
69232   arg3 = (float)jarg3;
69233   arg4 = (Dali::Vector3 *)jarg4;
69234   if (!arg4) {
69235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69236     return 0;
69237   }
69238   {
69239     try {
69240       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69241     } catch (std::out_of_range& e) {
69242       {
69243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69244       };
69245     } catch (std::exception& e) {
69246       {
69247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (...) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69252       };
69253     }
69254   }
69255   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69256   return jresult;
69257 }
69258
69259
69260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69261   void * jresult ;
69262   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69263   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69264
69265   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69266   {
69267     try {
69268       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69269     } catch (std::out_of_range& e) {
69270       {
69271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69272       };
69273     } catch (std::exception& e) {
69274       {
69275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (...) {
69278       {
69279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69280       };
69281     }
69282   }
69283   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69284   return jresult;
69285 }
69286
69287
69288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69289   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69290
69291   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69292   {
69293     try {
69294       delete arg1;
69295     } catch (std::out_of_range& e) {
69296       {
69297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69298       };
69299     } catch (std::exception& e) {
69300       {
69301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69302       };
69303     } catch (...) {
69304       {
69305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69306       };
69307     }
69308   }
69309 }
69310
69311
69312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69313   unsigned int jresult ;
69314   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69315   unsigned int result;
69316
69317   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69318   {
69319     try {
69320       result = (unsigned int)(arg1)->GetNumberOfItems();
69321     } catch (std::out_of_range& e) {
69322       {
69323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69324       };
69325     } catch (std::exception& e) {
69326       {
69327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69328       };
69329     } catch (...) {
69330       {
69331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69332       };
69333     }
69334   }
69335   jresult = result;
69336   return jresult;
69337 }
69338
69339
69340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69341   void * jresult ;
69342   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69343   unsigned int arg2 ;
69344   Dali::Actor result;
69345
69346   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69347   arg2 = (unsigned int)jarg2;
69348   {
69349     try {
69350       result = (arg1)->NewItem(arg2);
69351     } catch (std::out_of_range& e) {
69352       {
69353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (std::exception& e) {
69356       {
69357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69358       };
69359     } catch (...) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69362       };
69363     }
69364   }
69365   jresult = new Dali::Actor((const Dali::Actor &)result);
69366   return jresult;
69367 }
69368
69369
69370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69371   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69372   unsigned int arg2 ;
69373   Dali::Actor arg3 ;
69374   Dali::Actor *argp3 ;
69375
69376   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69377   arg2 = (unsigned int)jarg2;
69378   argp3 = (Dali::Actor *)jarg3;
69379   if (!argp3) {
69380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69381     return ;
69382   }
69383   arg3 = *argp3;
69384   {
69385     try {
69386       (arg1)->ItemReleased(arg2,arg3);
69387     } catch (std::out_of_range& e) {
69388       {
69389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69390       };
69391     } catch (std::exception& e) {
69392       {
69393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69394       };
69395     } catch (...) {
69396       {
69397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69398       };
69399     }
69400   }
69401 }
69402
69403
69404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69405   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69406   unsigned int arg2 ;
69407   Dali::Actor arg3 ;
69408   Dali::Actor *argp3 ;
69409
69410   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69411   arg2 = (unsigned int)jarg2;
69412   argp3 = (Dali::Actor *)jarg3;
69413   if (!argp3) {
69414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69415     return ;
69416   }
69417   arg3 = *argp3;
69418   {
69419     try {
69420       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69421     } catch (std::out_of_range& e) {
69422       {
69423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69424       };
69425     } catch (std::exception& e) {
69426       {
69427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69428       };
69429     } catch (...) {
69430       {
69431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69432       };
69433     }
69434   }
69435 }
69436
69437
69438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69439   void * jresult ;
69440   Dali::Toolkit::ItemFactory *result = 0 ;
69441
69442   {
69443     try {
69444       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69445     } catch (std::out_of_range& e) {
69446       {
69447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69448       };
69449     } catch (std::exception& e) {
69450       {
69451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69452       };
69453     } catch (...) {
69454       {
69455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69456       };
69457     }
69458   }
69459   jresult = (void *)result;
69460   return jresult;
69461 }
69462
69463
69464 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) {
69465   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69466   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69467   if (director) {
69468     director->swig_connect_director(callback0, callback1, callback2);
69469   }
69470 }
69471
69472
69473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69474   int jresult ;
69475   int result;
69476
69477   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69478   jresult = (int)result;
69479   return jresult;
69480 }
69481
69482
69483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69484   int jresult ;
69485   int result;
69486
69487   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69488   jresult = (int)result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69494   int jresult ;
69495   int result;
69496
69497   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69498   jresult = (int)result;
69499   return jresult;
69500 }
69501
69502
69503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69504   int jresult ;
69505   int result;
69506
69507   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69508   jresult = (int)result;
69509   return jresult;
69510 }
69511
69512
69513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69514   int jresult ;
69515   int result;
69516
69517   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69518   jresult = (int)result;
69519   return jresult;
69520 }
69521
69522
69523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69524   int jresult ;
69525   int result;
69526
69527   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69528   jresult = (int)result;
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69534   int jresult ;
69535   int result;
69536
69537   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69538   jresult = (int)result;
69539   return jresult;
69540 }
69541
69542
69543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69544   int jresult ;
69545   int result;
69546
69547   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69548   jresult = (int)result;
69549   return jresult;
69550 }
69551
69552
69553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69554   int jresult ;
69555   int result;
69556
69557   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69558   jresult = (int)result;
69559   return jresult;
69560 }
69561
69562
69563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69564   int jresult ;
69565   int result;
69566
69567   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69568   jresult = (int)result;
69569   return jresult;
69570 }
69571
69572
69573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69574   int jresult ;
69575   int result;
69576
69577   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69578   jresult = (int)result;
69579   return jresult;
69580 }
69581
69582
69583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69584   void * jresult ;
69585   Dali::Toolkit::ItemView::Property *result = 0 ;
69586
69587   {
69588     try {
69589       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69590     } catch (std::out_of_range& e) {
69591       {
69592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69593       };
69594     } catch (std::exception& e) {
69595       {
69596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69597       };
69598     } catch (...) {
69599       {
69600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69601       };
69602     }
69603   }
69604   jresult = (void *)result;
69605   return jresult;
69606 }
69607
69608
69609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69610   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69611
69612   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69613   {
69614     try {
69615       delete arg1;
69616     } catch (std::out_of_range& e) {
69617       {
69618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69619       };
69620     } catch (std::exception& e) {
69621       {
69622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69623       };
69624     } catch (...) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69627       };
69628     }
69629   }
69630 }
69631
69632
69633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69634   void * jresult ;
69635   Dali::Toolkit::ItemView *result = 0 ;
69636
69637   {
69638     try {
69639       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69640     } catch (std::out_of_range& e) {
69641       {
69642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69643       };
69644     } catch (std::exception& e) {
69645       {
69646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69647       };
69648     } catch (...) {
69649       {
69650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69651       };
69652     }
69653   }
69654   jresult = (void *)result;
69655   return jresult;
69656 }
69657
69658
69659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69660   void * jresult ;
69661   Dali::Toolkit::ItemView *arg1 = 0 ;
69662   Dali::Toolkit::ItemView *result = 0 ;
69663
69664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69665   if (!arg1) {
69666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69667     return 0;
69668   }
69669   {
69670     try {
69671       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69672     } catch (std::out_of_range& e) {
69673       {
69674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (std::exception& e) {
69677       {
69678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69679       };
69680     } catch (...) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69683       };
69684     }
69685   }
69686   jresult = (void *)result;
69687   return jresult;
69688 }
69689
69690
69691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69692   void * jresult ;
69693   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69694   Dali::Toolkit::ItemView *arg2 = 0 ;
69695   Dali::Toolkit::ItemView *result = 0 ;
69696
69697   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69698   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69699   if (!arg2) {
69700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69701     return 0;
69702   }
69703   {
69704     try {
69705       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69706     } catch (std::out_of_range& e) {
69707       {
69708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (std::exception& e) {
69711       {
69712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69713       };
69714     } catch (...) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69717       };
69718     }
69719   }
69720   jresult = (void *)result;
69721   return jresult;
69722 }
69723
69724
69725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69727
69728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69729   {
69730     try {
69731       delete arg1;
69732     } catch (std::out_of_range& e) {
69733       {
69734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69735       };
69736     } catch (std::exception& e) {
69737       {
69738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69739       };
69740     } catch (...) {
69741       {
69742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69743       };
69744     }
69745   }
69746 }
69747
69748
69749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69750   void * jresult ;
69751   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69752   Dali::Toolkit::ItemView result;
69753
69754   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69755   if (!arg1) {
69756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69757     return 0;
69758   }
69759   {
69760     try {
69761       result = Dali::Toolkit::ItemView::New(*arg1);
69762     } catch (std::out_of_range& e) {
69763       {
69764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69765       };
69766     } catch (std::exception& e) {
69767       {
69768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (...) {
69771       {
69772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69773       };
69774     }
69775   }
69776   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69777   return jresult;
69778 }
69779
69780
69781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69782   void * jresult ;
69783   Dali::BaseHandle arg1 ;
69784   Dali::BaseHandle *argp1 ;
69785   Dali::Toolkit::ItemView result;
69786
69787   argp1 = (Dali::BaseHandle *)jarg1;
69788   if (!argp1) {
69789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69790     return 0;
69791   }
69792   arg1 = *argp1;
69793   {
69794     try {
69795       result = Dali::Toolkit::ItemView::DownCast(arg1);
69796     } catch (std::out_of_range& e) {
69797       {
69798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69799       };
69800     } catch (std::exception& e) {
69801       {
69802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69803       };
69804     } catch (...) {
69805       {
69806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69807       };
69808     }
69809   }
69810   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69811   return jresult;
69812 }
69813
69814
69815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69816   unsigned int jresult ;
69817   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69818   unsigned int result;
69819
69820   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69821   {
69822     try {
69823       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69824     } catch (std::out_of_range& e) {
69825       {
69826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69827       };
69828     } catch (std::exception& e) {
69829       {
69830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69831       };
69832     } catch (...) {
69833       {
69834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69835       };
69836     }
69837   }
69838   jresult = result;
69839   return jresult;
69840 }
69841
69842
69843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69845   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69846
69847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69848   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69849   if (!arg2) {
69850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69851     return ;
69852   }
69853   {
69854     try {
69855       (arg1)->AddLayout(*arg2);
69856     } catch (std::out_of_range& e) {
69857       {
69858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69859       };
69860     } catch (std::exception& e) {
69861       {
69862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69863       };
69864     } catch (...) {
69865       {
69866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69867       };
69868     }
69869   }
69870 }
69871
69872
69873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69874   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69875   unsigned int arg2 ;
69876
69877   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69878   arg2 = (unsigned int)jarg2;
69879   {
69880     try {
69881       (arg1)->RemoveLayout(arg2);
69882     } catch (std::out_of_range& e) {
69883       {
69884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (std::exception& e) {
69887       {
69888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69893       };
69894     }
69895   }
69896 }
69897
69898
69899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69900   void * jresult ;
69901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69902   unsigned int arg2 ;
69903   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69904
69905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69906   arg2 = (unsigned int)jarg2;
69907   {
69908     try {
69909       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69910     } catch (std::out_of_range& e) {
69911       {
69912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69913       };
69914     } catch (std::exception& e) {
69915       {
69916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69917       };
69918     } catch (...) {
69919       {
69920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69921       };
69922     }
69923   }
69924   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69925   return jresult;
69926 }
69927
69928
69929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69930   void * jresult ;
69931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69932   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69933
69934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69935   {
69936     try {
69937       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (...) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69949       };
69950     }
69951   }
69952   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69953   return jresult;
69954 }
69955
69956
69957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69958   float jresult ;
69959   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69960   Dali::Toolkit::ItemId arg2 ;
69961   float result;
69962
69963   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69964   arg2 = (Dali::Toolkit::ItemId)jarg2;
69965   {
69966     try {
69967       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (...) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69979       };
69980     }
69981   }
69982   jresult = result;
69983   return jresult;
69984 }
69985
69986
69987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69988   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69989   unsigned int arg2 ;
69990   Dali::Vector3 arg3 ;
69991   float arg4 ;
69992   Dali::Vector3 *argp3 ;
69993
69994   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69995   arg2 = (unsigned int)jarg2;
69996   argp3 = (Dali::Vector3 *)jarg3;
69997   if (!argp3) {
69998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69999     return ;
70000   }
70001   arg3 = *argp3;
70002   arg4 = (float)jarg4;
70003   {
70004     try {
70005       (arg1)->ActivateLayout(arg2,arg3,arg4);
70006     } catch (std::out_of_range& e) {
70007       {
70008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70009       };
70010     } catch (std::exception& e) {
70011       {
70012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70013       };
70014     } catch (...) {
70015       {
70016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70017       };
70018     }
70019   }
70020 }
70021
70022
70023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70024   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70025
70026   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70027   {
70028     try {
70029       (arg1)->DeactivateCurrentLayout();
70030     } catch (std::out_of_range& e) {
70031       {
70032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70033       };
70034     } catch (std::exception& e) {
70035       {
70036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70037       };
70038     } catch (...) {
70039       {
70040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70041       };
70042     }
70043   }
70044 }
70045
70046
70047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70049   float arg2 ;
70050
70051   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70052   arg2 = (float)jarg2;
70053   {
70054     try {
70055       (arg1)->SetMinimumSwipeSpeed(arg2);
70056     } catch (std::out_of_range& e) {
70057       {
70058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70059       };
70060     } catch (std::exception& e) {
70061       {
70062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70063       };
70064     } catch (...) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70067       };
70068     }
70069   }
70070 }
70071
70072
70073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70074   float jresult ;
70075   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70076   float result;
70077
70078   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70079   {
70080     try {
70081       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70082     } catch (std::out_of_range& e) {
70083       {
70084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (std::exception& e) {
70087       {
70088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (...) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70093       };
70094     }
70095   }
70096   jresult = result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70102   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70103   float arg2 ;
70104
70105   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70106   arg2 = (float)jarg2;
70107   {
70108     try {
70109       (arg1)->SetMinimumSwipeDistance(arg2);
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70117       };
70118     } catch (...) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70121       };
70122     }
70123   }
70124 }
70125
70126
70127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70128   float jresult ;
70129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70130   float result;
70131
70132   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70133   {
70134     try {
70135       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70136     } catch (std::out_of_range& e) {
70137       {
70138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70139       };
70140     } catch (std::exception& e) {
70141       {
70142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (...) {
70145       {
70146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70147       };
70148     }
70149   }
70150   jresult = result;
70151   return jresult;
70152 }
70153
70154
70155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70156   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70157   float arg2 ;
70158
70159   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70160   arg2 = (float)jarg2;
70161   {
70162     try {
70163       (arg1)->SetWheelScrollDistanceStep(arg2);
70164     } catch (std::out_of_range& e) {
70165       {
70166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70167       };
70168     } catch (std::exception& e) {
70169       {
70170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70171       };
70172     } catch (...) {
70173       {
70174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70175       };
70176     }
70177   }
70178 }
70179
70180
70181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70182   float jresult ;
70183   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70184   float result;
70185
70186   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70187   {
70188     try {
70189       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70190     } catch (std::out_of_range& e) {
70191       {
70192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (std::exception& e) {
70195       {
70196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70197       };
70198     } catch (...) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70201       };
70202     }
70203   }
70204   jresult = result;
70205   return jresult;
70206 }
70207
70208
70209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70211   bool arg2 ;
70212
70213   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70214   arg2 = jarg2 ? true : false;
70215   {
70216     try {
70217       (arg1)->SetAnchoring(arg2);
70218     } catch (std::out_of_range& e) {
70219       {
70220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70221       };
70222     } catch (std::exception& e) {
70223       {
70224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70225       };
70226     } catch (...) {
70227       {
70228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70229       };
70230     }
70231   }
70232 }
70233
70234
70235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70236   unsigned int jresult ;
70237   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70238   bool result;
70239
70240   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70241   {
70242     try {
70243       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70244     } catch (std::out_of_range& e) {
70245       {
70246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70247       };
70248     } catch (std::exception& e) {
70249       {
70250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70251       };
70252     } catch (...) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70255       };
70256     }
70257   }
70258   jresult = result;
70259   return jresult;
70260 }
70261
70262
70263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70265   float arg2 ;
70266
70267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70268   arg2 = (float)jarg2;
70269   {
70270     try {
70271       (arg1)->SetAnchoringDuration(arg2);
70272     } catch (std::out_of_range& e) {
70273       {
70274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70275       };
70276     } catch (std::exception& e) {
70277       {
70278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70279       };
70280     } catch (...) {
70281       {
70282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70283       };
70284     }
70285   }
70286 }
70287
70288
70289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70290   float jresult ;
70291   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70292   float result;
70293
70294   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70295   {
70296     try {
70297       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70298     } catch (std::out_of_range& e) {
70299       {
70300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70301       };
70302     } catch (std::exception& e) {
70303       {
70304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70305       };
70306     } catch (...) {
70307       {
70308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70309       };
70310     }
70311   }
70312   jresult = result;
70313   return jresult;
70314 }
70315
70316
70317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70318   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70319   Dali::Toolkit::ItemId arg2 ;
70320   float arg3 ;
70321
70322   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70323   arg2 = (Dali::Toolkit::ItemId)jarg2;
70324   arg3 = (float)jarg3;
70325   {
70326     try {
70327       (arg1)->ScrollToItem(arg2,arg3);
70328     } catch (std::out_of_range& e) {
70329       {
70330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70331       };
70332     } catch (std::exception& e) {
70333       {
70334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70335       };
70336     } catch (...) {
70337       {
70338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70339       };
70340     }
70341   }
70342 }
70343
70344
70345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70347   float arg2 ;
70348
70349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70350   arg2 = (float)jarg2;
70351   {
70352     try {
70353       (arg1)->SetRefreshInterval(arg2);
70354     } catch (std::out_of_range& e) {
70355       {
70356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70357       };
70358     } catch (std::exception& e) {
70359       {
70360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70361       };
70362     } catch (...) {
70363       {
70364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70365       };
70366     }
70367   }
70368 }
70369
70370
70371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70372   float jresult ;
70373   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70374   float result;
70375
70376   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70377   {
70378     try {
70379       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70380     } catch (std::out_of_range& e) {
70381       {
70382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70383       };
70384     } catch (std::exception& e) {
70385       {
70386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70387       };
70388     } catch (...) {
70389       {
70390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70391       };
70392     }
70393   }
70394   jresult = result;
70395   return jresult;
70396 }
70397
70398
70399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70400   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70401
70402   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70403   {
70404     try {
70405       (arg1)->Refresh();
70406     } catch (std::out_of_range& e) {
70407       {
70408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70409       };
70410     } catch (std::exception& e) {
70411       {
70412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70413       };
70414     } catch (...) {
70415       {
70416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70417       };
70418     }
70419   }
70420 }
70421
70422
70423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70424   void * jresult ;
70425   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70426   Dali::Toolkit::ItemId arg2 ;
70427   Dali::Actor result;
70428
70429   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70430   arg2 = (Dali::Toolkit::ItemId)jarg2;
70431   {
70432     try {
70433       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70434     } catch (std::out_of_range& e) {
70435       {
70436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70437       };
70438     } catch (std::exception& e) {
70439       {
70440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70441       };
70442     } catch (...) {
70443       {
70444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70445       };
70446     }
70447   }
70448   jresult = new Dali::Actor((const Dali::Actor &)result);
70449   return jresult;
70450 }
70451
70452
70453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70454   unsigned int jresult ;
70455   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70456   Dali::Actor arg2 ;
70457   Dali::Actor *argp2 ;
70458   Dali::Toolkit::ItemId result;
70459
70460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70461   argp2 = (Dali::Actor *)jarg2;
70462   if (!argp2) {
70463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70464     return 0;
70465   }
70466   arg2 = *argp2;
70467   {
70468     try {
70469       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70470     } catch (std::out_of_range& e) {
70471       {
70472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70473       };
70474     } catch (std::exception& e) {
70475       {
70476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70477       };
70478     } catch (...) {
70479       {
70480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70481       };
70482     }
70483   }
70484   jresult = result;
70485   return jresult;
70486 }
70487
70488
70489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70491   Dali::Toolkit::Item arg2 ;
70492   float arg3 ;
70493   Dali::Toolkit::Item *argp2 ;
70494
70495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70496   argp2 = (Dali::Toolkit::Item *)jarg2;
70497   if (!argp2) {
70498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70499     return ;
70500   }
70501   arg2 = *argp2;
70502   arg3 = (float)jarg3;
70503   {
70504     try {
70505       (arg1)->InsertItem(arg2,arg3);
70506     } catch (std::out_of_range& e) {
70507       {
70508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70509       };
70510     } catch (std::exception& e) {
70511       {
70512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70513       };
70514     } catch (...) {
70515       {
70516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70517       };
70518     }
70519   }
70520 }
70521
70522
70523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70524   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70525   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70526   float arg3 ;
70527
70528   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70529   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70530   if (!arg2) {
70531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70532     return ;
70533   }
70534   arg3 = (float)jarg3;
70535   {
70536     try {
70537       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70538     } catch (std::out_of_range& e) {
70539       {
70540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70541       };
70542     } catch (std::exception& e) {
70543       {
70544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70545       };
70546     } catch (...) {
70547       {
70548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70549       };
70550     }
70551   }
70552 }
70553
70554
70555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70557   Dali::Toolkit::ItemId arg2 ;
70558   float arg3 ;
70559
70560   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70561   arg2 = (Dali::Toolkit::ItemId)jarg2;
70562   arg3 = (float)jarg3;
70563   {
70564     try {
70565       (arg1)->RemoveItem(arg2,arg3);
70566     } catch (std::out_of_range& e) {
70567       {
70568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70569       };
70570     } catch (std::exception& e) {
70571       {
70572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70573       };
70574     } catch (...) {
70575       {
70576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70577       };
70578     }
70579   }
70580 }
70581
70582
70583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70584   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70585   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70586   float arg3 ;
70587
70588   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70589   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70590   if (!arg2) {
70591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70592     return ;
70593   }
70594   arg3 = (float)jarg3;
70595   {
70596     try {
70597       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70598     } catch (std::out_of_range& e) {
70599       {
70600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70601       };
70602     } catch (std::exception& e) {
70603       {
70604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70609       };
70610     }
70611   }
70612 }
70613
70614
70615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70616   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70617   Dali::Toolkit::Item arg2 ;
70618   float arg3 ;
70619   Dali::Toolkit::Item *argp2 ;
70620
70621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70622   argp2 = (Dali::Toolkit::Item *)jarg2;
70623   if (!argp2) {
70624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70625     return ;
70626   }
70627   arg2 = *argp2;
70628   arg3 = (float)jarg3;
70629   {
70630     try {
70631       (arg1)->ReplaceItem(arg2,arg3);
70632     } catch (std::out_of_range& e) {
70633       {
70634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70635       };
70636     } catch (std::exception& e) {
70637       {
70638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70639       };
70640     } catch (...) {
70641       {
70642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70643       };
70644     }
70645   }
70646 }
70647
70648
70649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70650   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70651   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70652   float arg3 ;
70653
70654   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70655   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70656   if (!arg2) {
70657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70658     return ;
70659   }
70660   arg3 = (float)jarg3;
70661   {
70662     try {
70663       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70664     } catch (std::out_of_range& e) {
70665       {
70666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70667       };
70668     } catch (std::exception& e) {
70669       {
70670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70671       };
70672     } catch (...) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70675       };
70676     }
70677   }
70678 }
70679
70680
70681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70682   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70683   Dali::Vector3 *arg2 = 0 ;
70684
70685   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70686   arg2 = (Dali::Vector3 *)jarg2;
70687   if (!arg2) {
70688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70689     return ;
70690   }
70691   {
70692     try {
70693       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70694     } catch (std::out_of_range& e) {
70695       {
70696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70697       };
70698     } catch (std::exception& e) {
70699       {
70700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70701       };
70702     } catch (...) {
70703       {
70704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70705       };
70706     }
70707   }
70708 }
70709
70710
70711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70712   void * jresult ;
70713   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70714   Dali::Vector3 result;
70715
70716   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70717   {
70718     try {
70719       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70720     } catch (std::out_of_range& e) {
70721       {
70722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70723       };
70724     } catch (std::exception& e) {
70725       {
70726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70727       };
70728     } catch (...) {
70729       {
70730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70731       };
70732     }
70733   }
70734   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70735   return jresult;
70736 }
70737
70738
70739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70740   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70741   Dali::Vector3 *arg2 = 0 ;
70742
70743   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70744   arg2 = (Dali::Vector3 *)jarg2;
70745   if (!arg2) {
70746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70747     return ;
70748   }
70749   {
70750     try {
70751       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70752     } catch (std::out_of_range& e) {
70753       {
70754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70755       };
70756     } catch (std::exception& e) {
70757       {
70758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70759       };
70760     } catch (...) {
70761       {
70762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70763       };
70764     }
70765   }
70766 }
70767
70768
70769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70770   void * jresult ;
70771   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70772   Dali::Vector3 result;
70773
70774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70775   {
70776     try {
70777       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70778     } catch (std::out_of_range& e) {
70779       {
70780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (std::exception& e) {
70783       {
70784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70785       };
70786     } catch (...) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70789       };
70790     }
70791   }
70792   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70793   return jresult;
70794 }
70795
70796
70797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70799   Dali::Toolkit::ItemRange *arg2 = 0 ;
70800
70801   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70802   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70803   if (!arg2) {
70804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70805     return ;
70806   }
70807   {
70808     try {
70809       (arg1)->GetItemsRange(*arg2);
70810     } catch (std::out_of_range& e) {
70811       {
70812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70813       };
70814     } catch (std::exception& e) {
70815       {
70816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70817       };
70818     } catch (...) {
70819       {
70820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70821       };
70822     }
70823   }
70824 }
70825
70826
70827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70828   void * jresult ;
70829   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70830   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70831
70832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70833   {
70834     try {
70835       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70843       };
70844     } catch (...) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70847       };
70848     }
70849   }
70850   jresult = (void *)result;
70851   return jresult;
70852 }
70853
70854
70855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70856   Dali::Vector3 *arg1 = 0 ;
70857   PropertyInputContainer *arg2 = 0 ;
70858
70859   arg1 = (Dali::Vector3 *)jarg1;
70860   if (!arg1) {
70861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70862     return ;
70863   }
70864   arg2 = (PropertyInputContainer *)jarg2;
70865   if (!arg2) {
70866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70867     return ;
70868   }
70869   {
70870     try {
70871       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70872     } catch (std::out_of_range& e) {
70873       {
70874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70875       };
70876     } catch (std::exception& e) {
70877       {
70878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70879       };
70880     } catch (...) {
70881       {
70882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70883       };
70884     }
70885   }
70886 }
70887
70888
70889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70890   Dali::Vector3 *arg1 = 0 ;
70891   PropertyInputContainer *arg2 = 0 ;
70892
70893   arg1 = (Dali::Vector3 *)jarg1;
70894   if (!arg1) {
70895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70896     return ;
70897   }
70898   arg2 = (PropertyInputContainer *)jarg2;
70899   if (!arg2) {
70900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70901     return ;
70902   }
70903   {
70904     try {
70905       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70906     } catch (std::out_of_range& e) {
70907       {
70908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70909       };
70910     } catch (std::exception& e) {
70911       {
70912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70913       };
70914     } catch (...) {
70915       {
70916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70917       };
70918     }
70919   }
70920 }
70921
70922
70923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70924   void * jresult ;
70925   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70926
70927   {
70928     try {
70929       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70930     } catch (std::out_of_range& e) {
70931       {
70932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70933       };
70934     } catch (std::exception& e) {
70935       {
70936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70937       };
70938     } catch (...) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70941       };
70942     }
70943   }
70944   jresult = (void *)result;
70945   return jresult;
70946 }
70947
70948
70949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70950   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70951
70952   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70953   {
70954     try {
70955       delete arg1;
70956     } catch (std::out_of_range& e) {
70957       {
70958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70959       };
70960     } catch (std::exception& e) {
70961       {
70962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70963       };
70964     } catch (...) {
70965       {
70966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70967       };
70968     }
70969   }
70970 }
70971
70972
70973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70974   void * jresult ;
70975   Dali::Path arg1 ;
70976   Dali::Vector3 *arg2 = 0 ;
70977   Dali::Property::Index arg3 ;
70978   Dali::Vector3 *arg4 = 0 ;
70979   unsigned int arg5 ;
70980   Dali::Path *argp1 ;
70981   Dali::Toolkit::ScrollViewPagePathEffect result;
70982
70983   argp1 = (Dali::Path *)jarg1;
70984   if (!argp1) {
70985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70986     return 0;
70987   }
70988   arg1 = *argp1;
70989   arg2 = (Dali::Vector3 *)jarg2;
70990   if (!arg2) {
70991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70992     return 0;
70993   }
70994   arg3 = (Dali::Property::Index)jarg3;
70995   arg4 = (Dali::Vector3 *)jarg4;
70996   if (!arg4) {
70997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70998     return 0;
70999   }
71000   arg5 = (unsigned int)jarg5;
71001   {
71002     try {
71003       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71004     } catch (std::out_of_range& e) {
71005       {
71006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71007       };
71008     } catch (std::exception& e) {
71009       {
71010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71011       };
71012     } catch (...) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71015       };
71016     }
71017   }
71018   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71019   return jresult;
71020 }
71021
71022
71023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71024   void * jresult ;
71025   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71026
71027   {
71028     try {
71029       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71030     } catch (std::out_of_range& e) {
71031       {
71032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71033       };
71034     } catch (std::exception& e) {
71035       {
71036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71037       };
71038     } catch (...) {
71039       {
71040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71041       };
71042     }
71043   }
71044   jresult = (void *)result;
71045   return jresult;
71046 }
71047
71048
71049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71050   void * jresult ;
71051   Dali::BaseHandle arg1 ;
71052   Dali::BaseHandle *argp1 ;
71053   Dali::Toolkit::ScrollViewPagePathEffect result;
71054
71055   argp1 = (Dali::BaseHandle *)jarg1;
71056   if (!argp1) {
71057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71058     return 0;
71059   }
71060   arg1 = *argp1;
71061   {
71062     try {
71063       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71064     } catch (std::out_of_range& e) {
71065       {
71066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71067       };
71068     } catch (std::exception& e) {
71069       {
71070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71071       };
71072     } catch (...) {
71073       {
71074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71075       };
71076     }
71077   }
71078   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71079   return jresult;
71080 }
71081
71082
71083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71084   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71085   Dali::Actor arg2 ;
71086   unsigned int arg3 ;
71087   Dali::Actor *argp2 ;
71088
71089   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71090   argp2 = (Dali::Actor *)jarg2;
71091   if (!argp2) {
71092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71093     return ;
71094   }
71095   arg2 = *argp2;
71096   arg3 = (unsigned int)jarg3;
71097   {
71098     try {
71099       (arg1)->ApplyToPage(arg2,arg3);
71100     } catch (std::out_of_range& e) {
71101       {
71102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71103       };
71104     } catch (std::exception& e) {
71105       {
71106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (...) {
71109       {
71110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71111       };
71112     }
71113   }
71114 }
71115
71116
71117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71118   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71119
71120   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71121   {
71122     try {
71123       delete arg1;
71124     } catch (std::out_of_range& e) {
71125       {
71126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71127       };
71128     } catch (std::exception& e) {
71129       {
71130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71131       };
71132     } catch (...) {
71133       {
71134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71135       };
71136     }
71137   }
71138 }
71139
71140
71141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71142   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71143   Dali::Toolkit::ClampState arg2 ;
71144
71145   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71146   arg2 = (Dali::Toolkit::ClampState)jarg2;
71147   if (arg1) (arg1)->x = arg2;
71148 }
71149
71150
71151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71152   int jresult ;
71153   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71154   Dali::Toolkit::ClampState result;
71155
71156   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71157   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71158   jresult = (int)result;
71159   return jresult;
71160 }
71161
71162
71163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71164   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71165   Dali::Toolkit::ClampState arg2 ;
71166
71167   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71168   arg2 = (Dali::Toolkit::ClampState)jarg2;
71169   if (arg1) (arg1)->y = arg2;
71170 }
71171
71172
71173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71174   int jresult ;
71175   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71176   Dali::Toolkit::ClampState result;
71177
71178   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71179   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71180   jresult = (int)result;
71181   return jresult;
71182 }
71183
71184
71185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71186   void * jresult ;
71187   Dali::Toolkit::ClampState2D *result = 0 ;
71188
71189   {
71190     try {
71191       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71192     } catch (std::out_of_range& e) {
71193       {
71194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71195       };
71196     } catch (std::exception& e) {
71197       {
71198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71199       };
71200     } catch (...) {
71201       {
71202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71203       };
71204     }
71205   }
71206   jresult = (void *)result;
71207   return jresult;
71208 }
71209
71210
71211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71212   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71213
71214   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71215   {
71216     try {
71217       delete arg1;
71218     } catch (std::out_of_range& e) {
71219       {
71220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71221       };
71222     } catch (std::exception& e) {
71223       {
71224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71225       };
71226     } catch (...) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71229       };
71230     }
71231   }
71232 }
71233
71234
71235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71236   void * jresult ;
71237   float arg1 ;
71238   float arg2 ;
71239   bool arg3 ;
71240   Dali::Toolkit::RulerDomain *result = 0 ;
71241
71242   arg1 = (float)jarg1;
71243   arg2 = (float)jarg2;
71244   arg3 = jarg3 ? true : false;
71245   {
71246     try {
71247       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71248     } catch (std::out_of_range& e) {
71249       {
71250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71251       };
71252     } catch (std::exception& e) {
71253       {
71254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71255       };
71256     } catch (...) {
71257       {
71258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71259       };
71260     }
71261   }
71262   jresult = (void *)result;
71263   return jresult;
71264 }
71265
71266
71267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71268   void * jresult ;
71269   float arg1 ;
71270   float arg2 ;
71271   Dali::Toolkit::RulerDomain *result = 0 ;
71272
71273   arg1 = (float)jarg1;
71274   arg2 = (float)jarg2;
71275   {
71276     try {
71277       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71278     } catch (std::out_of_range& e) {
71279       {
71280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71281       };
71282     } catch (std::exception& e) {
71283       {
71284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71285       };
71286     } catch (...) {
71287       {
71288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71289       };
71290     }
71291   }
71292   jresult = (void *)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71298   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71299   float arg2 ;
71300
71301   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71302   arg2 = (float)jarg2;
71303   if (arg1) (arg1)->min = arg2;
71304 }
71305
71306
71307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71308   float jresult ;
71309   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71310   float result;
71311
71312   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71313   result = (float) ((arg1)->min);
71314   jresult = result;
71315   return jresult;
71316 }
71317
71318
71319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71320   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71321   float arg2 ;
71322
71323   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71324   arg2 = (float)jarg2;
71325   if (arg1) (arg1)->max = arg2;
71326 }
71327
71328
71329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71330   float jresult ;
71331   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71332   float result;
71333
71334   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71335   result = (float) ((arg1)->max);
71336   jresult = result;
71337   return jresult;
71338 }
71339
71340
71341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71342   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71343   bool arg2 ;
71344
71345   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71346   arg2 = jarg2 ? true : false;
71347   if (arg1) (arg1)->enabled = arg2;
71348 }
71349
71350
71351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71352   unsigned int jresult ;
71353   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71354   bool result;
71355
71356   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71357   result = (bool) ((arg1)->enabled);
71358   jresult = result;
71359   return jresult;
71360 }
71361
71362
71363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71364   float jresult ;
71365   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71366   float arg2 ;
71367   float arg3 ;
71368   float arg4 ;
71369   float result;
71370
71371   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71372   arg2 = (float)jarg2;
71373   arg3 = (float)jarg3;
71374   arg4 = (float)jarg4;
71375   {
71376     try {
71377       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71378     } catch (std::out_of_range& e) {
71379       {
71380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71381       };
71382     } catch (std::exception& e) {
71383       {
71384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71385       };
71386     } catch (...) {
71387       {
71388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71389       };
71390     }
71391   }
71392   jresult = result;
71393   return jresult;
71394 }
71395
71396
71397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71398   float jresult ;
71399   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71400   float arg2 ;
71401   float arg3 ;
71402   float result;
71403
71404   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71405   arg2 = (float)jarg2;
71406   arg3 = (float)jarg3;
71407   {
71408     try {
71409       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71410     } catch (std::out_of_range& e) {
71411       {
71412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71413       };
71414     } catch (std::exception& e) {
71415       {
71416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (...) {
71419       {
71420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71421       };
71422     }
71423   }
71424   jresult = result;
71425   return jresult;
71426 }
71427
71428
71429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71430   float jresult ;
71431   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71432   float arg2 ;
71433   float result;
71434
71435   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71436   arg2 = (float)jarg2;
71437   {
71438     try {
71439       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71440     } catch (std::out_of_range& e) {
71441       {
71442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71443       };
71444     } catch (std::exception& e) {
71445       {
71446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71447       };
71448     } catch (...) {
71449       {
71450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71451       };
71452     }
71453   }
71454   jresult = result;
71455   return jresult;
71456 }
71457
71458
71459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71460   float jresult ;
71461   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71462   float arg2 ;
71463   float arg3 ;
71464   float arg4 ;
71465   Dali::Toolkit::ClampState *arg5 = 0 ;
71466   float result;
71467
71468   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71469   arg2 = (float)jarg2;
71470   arg3 = (float)jarg3;
71471   arg4 = (float)jarg4;
71472   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71473   if (!arg5) {
71474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71475     return 0;
71476   }
71477   {
71478     try {
71479       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71480     } catch (std::out_of_range& e) {
71481       {
71482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71483       };
71484     } catch (std::exception& e) {
71485       {
71486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71487       };
71488     } catch (...) {
71489       {
71490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71491       };
71492     }
71493   }
71494   jresult = result;
71495   return jresult;
71496 }
71497
71498
71499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71500   float jresult ;
71501   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71502   float result;
71503
71504   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71505   {
71506     try {
71507       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71508     } catch (std::out_of_range& e) {
71509       {
71510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71511       };
71512     } catch (std::exception& e) {
71513       {
71514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71515       };
71516     } catch (...) {
71517       {
71518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71519       };
71520     }
71521   }
71522   jresult = result;
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71528   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71529
71530   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71531   {
71532     try {
71533       delete arg1;
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71545       };
71546     }
71547   }
71548 }
71549
71550
71551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71552   float jresult ;
71553   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71554   float arg2 ;
71555   float arg3 ;
71556   float result;
71557
71558   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71559   arg2 = (float)jarg2;
71560   arg3 = (float)jarg3;
71561   {
71562     try {
71563       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71564     } catch (std::out_of_range& e) {
71565       {
71566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71567       };
71568     } catch (std::exception& e) {
71569       {
71570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71571       };
71572     } catch (...) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71575       };
71576     }
71577   }
71578   jresult = result;
71579   return jresult;
71580 }
71581
71582
71583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71584   float jresult ;
71585   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71586   float arg2 ;
71587   float result;
71588
71589   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71590   arg2 = (float)jarg2;
71591   {
71592     try {
71593       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71594     } catch (std::out_of_range& e) {
71595       {
71596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71597       };
71598     } catch (std::exception& e) {
71599       {
71600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71601       };
71602     } catch (...) {
71603       {
71604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71605       };
71606     }
71607   }
71608   jresult = result;
71609   return jresult;
71610 }
71611
71612
71613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71614   float jresult ;
71615   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71616   unsigned int arg2 ;
71617   unsigned int *arg3 = 0 ;
71618   bool arg4 ;
71619   float result;
71620
71621   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71622   arg2 = (unsigned int)jarg2;
71623   arg3 = (unsigned int *)jarg3;
71624   arg4 = jarg4 ? true : false;
71625   {
71626     try {
71627       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71628     } catch (std::out_of_range& e) {
71629       {
71630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71631       };
71632     } catch (std::exception& e) {
71633       {
71634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (...) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71639       };
71640     }
71641   }
71642   jresult = result;
71643   return jresult;
71644 }
71645
71646
71647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71648   unsigned int jresult ;
71649   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71650   float arg2 ;
71651   bool arg3 ;
71652   unsigned int result;
71653
71654   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71655   arg2 = (float)jarg2;
71656   arg3 = jarg3 ? true : false;
71657   {
71658     try {
71659       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71660     } catch (std::out_of_range& e) {
71661       {
71662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71663       };
71664     } catch (std::exception& e) {
71665       {
71666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71667       };
71668     } catch (...) {
71669       {
71670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71671       };
71672     }
71673   }
71674   jresult = result;
71675   return jresult;
71676 }
71677
71678
71679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71680   unsigned int jresult ;
71681   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71682   unsigned int result;
71683
71684   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71685   {
71686     try {
71687       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71688     } catch (std::out_of_range& e) {
71689       {
71690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71691       };
71692     } catch (std::exception& e) {
71693       {
71694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71695       };
71696     } catch (...) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71699       };
71700     }
71701   }
71702   jresult = result;
71703   return jresult;
71704 }
71705
71706
71707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71708   int jresult ;
71709   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71710   Dali::Toolkit::Ruler::RulerType result;
71711
71712   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71713   {
71714     try {
71715       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71716     } catch (std::out_of_range& e) {
71717       {
71718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71719       };
71720     } catch (std::exception& e) {
71721       {
71722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71723       };
71724     } catch (...) {
71725       {
71726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71727       };
71728     }
71729   }
71730   jresult = (int)result;
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71736   unsigned int jresult ;
71737   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71738   bool result;
71739
71740   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71741   {
71742     try {
71743       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71744     } catch (std::out_of_range& e) {
71745       {
71746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71747       };
71748     } catch (std::exception& e) {
71749       {
71750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71751       };
71752     } catch (...) {
71753       {
71754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71755       };
71756     }
71757   }
71758   jresult = result;
71759   return jresult;
71760 }
71761
71762
71763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71764   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71765
71766   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71767   {
71768     try {
71769       (arg1)->Enable();
71770     } catch (std::out_of_range& e) {
71771       {
71772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71773       };
71774     } catch (std::exception& e) {
71775       {
71776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71777       };
71778     } catch (...) {
71779       {
71780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71781       };
71782     }
71783   }
71784 }
71785
71786
71787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71788   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71789
71790   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71791   {
71792     try {
71793       (arg1)->Disable();
71794     } catch (std::out_of_range& e) {
71795       {
71796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71797       };
71798     } catch (std::exception& e) {
71799       {
71800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71801       };
71802     } catch (...) {
71803       {
71804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71805       };
71806     }
71807   }
71808 }
71809
71810
71811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71812   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71813   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71814   Dali::Toolkit::RulerDomain *argp2 ;
71815
71816   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71817   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71818   if (!argp2) {
71819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71820     return ;
71821   }
71822   arg2 = *argp2;
71823   {
71824     try {
71825       (arg1)->SetDomain(arg2);
71826     } catch (std::out_of_range& e) {
71827       {
71828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71829       };
71830     } catch (std::exception& e) {
71831       {
71832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71833       };
71834     } catch (...) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71837       };
71838     }
71839   }
71840 }
71841
71842
71843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71844   void * jresult ;
71845   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71846   Dali::Toolkit::RulerDomain *result = 0 ;
71847
71848   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71849   {
71850     try {
71851       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71852     } catch (std::out_of_range& e) {
71853       {
71854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71855       };
71856     } catch (std::exception& e) {
71857       {
71858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71859       };
71860     } catch (...) {
71861       {
71862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71863       };
71864     }
71865   }
71866   jresult = (void *)result;
71867   return jresult;
71868 }
71869
71870
71871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71872   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71873
71874   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71875   {
71876     try {
71877       (arg1)->DisableDomain();
71878     } catch (std::out_of_range& e) {
71879       {
71880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71881       };
71882     } catch (std::exception& e) {
71883       {
71884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71885       };
71886     } catch (...) {
71887       {
71888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71889       };
71890     }
71891   }
71892 }
71893
71894
71895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71896   float jresult ;
71897   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71898   float arg2 ;
71899   float arg3 ;
71900   float arg4 ;
71901   float result;
71902
71903   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71904   arg2 = (float)jarg2;
71905   arg3 = (float)jarg3;
71906   arg4 = (float)jarg4;
71907   {
71908     try {
71909       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71910     } catch (std::out_of_range& e) {
71911       {
71912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71913       };
71914     } catch (std::exception& e) {
71915       {
71916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71917       };
71918     } catch (...) {
71919       {
71920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71921       };
71922     }
71923   }
71924   jresult = result;
71925   return jresult;
71926 }
71927
71928
71929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71930   float jresult ;
71931   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71932   float arg2 ;
71933   float arg3 ;
71934   float result;
71935
71936   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71937   arg2 = (float)jarg2;
71938   arg3 = (float)jarg3;
71939   {
71940     try {
71941       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71942     } catch (std::out_of_range& e) {
71943       {
71944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71945       };
71946     } catch (std::exception& e) {
71947       {
71948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71949       };
71950     } catch (...) {
71951       {
71952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71953       };
71954     }
71955   }
71956   jresult = result;
71957   return jresult;
71958 }
71959
71960
71961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71962   float jresult ;
71963   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71964   float arg2 ;
71965   float result;
71966
71967   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71968   arg2 = (float)jarg2;
71969   {
71970     try {
71971       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
71972     } catch (std::out_of_range& e) {
71973       {
71974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71975       };
71976     } catch (std::exception& e) {
71977       {
71978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71979       };
71980     } catch (...) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71983       };
71984     }
71985   }
71986   jresult = result;
71987   return jresult;
71988 }
71989
71990
71991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71992   float jresult ;
71993   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71994   float arg2 ;
71995   float arg3 ;
71996   float arg4 ;
71997   Dali::Toolkit::ClampState *arg5 = 0 ;
71998   float result;
71999
72000   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72001   arg2 = (float)jarg2;
72002   arg3 = (float)jarg3;
72003   arg4 = (float)jarg4;
72004   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72005   if (!arg5) {
72006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72007     return 0;
72008   }
72009   {
72010     try {
72011       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72012     } catch (std::out_of_range& e) {
72013       {
72014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72015       };
72016     } catch (std::exception& e) {
72017       {
72018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72019       };
72020     } catch (...) {
72021       {
72022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72023       };
72024     }
72025   }
72026   jresult = result;
72027   return jresult;
72028 }
72029
72030
72031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72032   float jresult ;
72033   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72034   float arg2 ;
72035   float arg3 ;
72036   float arg4 ;
72037   float arg5 ;
72038   float result;
72039
72040   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72041   arg2 = (float)jarg2;
72042   arg3 = (float)jarg3;
72043   arg4 = (float)jarg4;
72044   arg5 = (float)jarg5;
72045   {
72046     try {
72047       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72048     } catch (std::out_of_range& e) {
72049       {
72050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72051       };
72052     } catch (std::exception& e) {
72053       {
72054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72055       };
72056     } catch (...) {
72057       {
72058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72059       };
72060     }
72061   }
72062   jresult = result;
72063   return jresult;
72064 }
72065
72066
72067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72068   float jresult ;
72069   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72070   float arg2 ;
72071   float arg3 ;
72072   float arg4 ;
72073   float result;
72074
72075   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72076   arg2 = (float)jarg2;
72077   arg3 = (float)jarg3;
72078   arg4 = (float)jarg4;
72079   {
72080     try {
72081       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72082     } catch (std::out_of_range& e) {
72083       {
72084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72085       };
72086     } catch (std::exception& e) {
72087       {
72088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72089       };
72090     } catch (...) {
72091       {
72092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72093       };
72094     }
72095   }
72096   jresult = result;
72097   return jresult;
72098 }
72099
72100
72101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72102   float jresult ;
72103   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72104   float arg2 ;
72105   float arg3 ;
72106   float result;
72107
72108   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72109   arg2 = (float)jarg2;
72110   arg3 = (float)jarg3;
72111   {
72112     try {
72113       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72114     } catch (std::out_of_range& e) {
72115       {
72116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72117       };
72118     } catch (std::exception& e) {
72119       {
72120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72121       };
72122     } catch (...) {
72123       {
72124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72125       };
72126     }
72127   }
72128   jresult = result;
72129   return jresult;
72130 }
72131
72132
72133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72134   float jresult ;
72135   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72136   float arg2 ;
72137   float result;
72138
72139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72140   arg2 = (float)jarg2;
72141   {
72142     try {
72143       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72144     } catch (std::out_of_range& e) {
72145       {
72146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72147       };
72148     } catch (std::exception& e) {
72149       {
72150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72151       };
72152     } catch (...) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72155       };
72156     }
72157   }
72158   jresult = result;
72159   return jresult;
72160 }
72161
72162
72163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72164   float jresult ;
72165   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72166   float arg2 ;
72167   float arg3 ;
72168   float arg4 ;
72169   float arg5 ;
72170   Dali::Toolkit::ClampState *arg6 = 0 ;
72171   float result;
72172
72173   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72174   arg2 = (float)jarg2;
72175   arg3 = (float)jarg3;
72176   arg4 = (float)jarg4;
72177   arg5 = (float)jarg5;
72178   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72179   if (!arg6) {
72180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72181     return 0;
72182   }
72183   {
72184     try {
72185       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72186     } catch (std::out_of_range& e) {
72187       {
72188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72189       };
72190     } catch (std::exception& e) {
72191       {
72192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72193       };
72194     } catch (...) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72197       };
72198     }
72199   }
72200   jresult = result;
72201   return jresult;
72202 }
72203
72204
72205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72206   void * jresult ;
72207   Dali::Toolkit::DefaultRuler *result = 0 ;
72208
72209   {
72210     try {
72211       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72212     } catch (std::out_of_range& e) {
72213       {
72214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72215       };
72216     } catch (std::exception& e) {
72217       {
72218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72219       };
72220     } catch (...) {
72221       {
72222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72223       };
72224     }
72225   }
72226   jresult = (void *)result;
72227   return jresult;
72228 }
72229
72230
72231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72232   float jresult ;
72233   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72234   float arg2 ;
72235   float arg3 ;
72236   float result;
72237
72238   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72239   arg2 = (float)jarg2;
72240   arg3 = (float)jarg3;
72241   {
72242     try {
72243       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72244     } catch (std::out_of_range& e) {
72245       {
72246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (std::exception& e) {
72249       {
72250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (...) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72255       };
72256     }
72257   }
72258   jresult = result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72264   float jresult ;
72265   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72266   unsigned int arg2 ;
72267   unsigned int *arg3 = 0 ;
72268   bool arg4 ;
72269   float result;
72270
72271   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72272   arg2 = (unsigned int)jarg2;
72273   arg3 = (unsigned int *)jarg3;
72274   arg4 = jarg4 ? true : false;
72275   {
72276     try {
72277       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72278     } catch (std::out_of_range& e) {
72279       {
72280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72281       };
72282     } catch (std::exception& e) {
72283       {
72284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72285       };
72286     } catch (...) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72289       };
72290     }
72291   }
72292   jresult = result;
72293   return jresult;
72294 }
72295
72296
72297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72298   unsigned int jresult ;
72299   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72300   float arg2 ;
72301   bool arg3 ;
72302   unsigned int result;
72303
72304   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72305   arg2 = (float)jarg2;
72306   arg3 = jarg3 ? true : false;
72307   {
72308     try {
72309       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72310     } catch (std::out_of_range& e) {
72311       {
72312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72313       };
72314     } catch (std::exception& e) {
72315       {
72316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72317       };
72318     } catch (...) {
72319       {
72320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72321       };
72322     }
72323   }
72324   jresult = result;
72325   return jresult;
72326 }
72327
72328
72329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72330   unsigned int jresult ;
72331   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72332   unsigned int result;
72333
72334   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72335   {
72336     try {
72337       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72338     } catch (std::out_of_range& e) {
72339       {
72340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (std::exception& e) {
72343       {
72344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72345       };
72346     } catch (...) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72349       };
72350     }
72351   }
72352   jresult = result;
72353   return jresult;
72354 }
72355
72356
72357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72358   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72359
72360   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72361   {
72362     try {
72363       delete arg1;
72364     } catch (std::out_of_range& e) {
72365       {
72366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (std::exception& e) {
72369       {
72370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72375       };
72376     }
72377   }
72378 }
72379
72380
72381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72382   void * jresult ;
72383   float arg1 ;
72384   Dali::Toolkit::FixedRuler *result = 0 ;
72385
72386   arg1 = (float)jarg1;
72387   {
72388     try {
72389       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (...) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72401       };
72402     }
72403   }
72404   jresult = (void *)result;
72405   return jresult;
72406 }
72407
72408
72409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72410   void * jresult ;
72411   Dali::Toolkit::FixedRuler *result = 0 ;
72412
72413   {
72414     try {
72415       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72416     } catch (std::out_of_range& e) {
72417       {
72418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72419       };
72420     } catch (std::exception& e) {
72421       {
72422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72423       };
72424     } catch (...) {
72425       {
72426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72427       };
72428     }
72429   }
72430   jresult = (void *)result;
72431   return jresult;
72432 }
72433
72434
72435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72436   float jresult ;
72437   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72438   float arg2 ;
72439   float arg3 ;
72440   float result;
72441
72442   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72443   arg2 = (float)jarg2;
72444   arg3 = (float)jarg3;
72445   {
72446     try {
72447       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72448     } catch (std::out_of_range& e) {
72449       {
72450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72451       };
72452     } catch (std::exception& e) {
72453       {
72454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72455       };
72456     } catch (...) {
72457       {
72458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72459       };
72460     }
72461   }
72462   jresult = result;
72463   return jresult;
72464 }
72465
72466
72467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72468   float jresult ;
72469   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72470   unsigned int arg2 ;
72471   unsigned int *arg3 = 0 ;
72472   bool arg4 ;
72473   float result;
72474
72475   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72476   arg2 = (unsigned int)jarg2;
72477   arg3 = (unsigned int *)jarg3;
72478   arg4 = jarg4 ? true : false;
72479   {
72480     try {
72481       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72482     } catch (std::out_of_range& e) {
72483       {
72484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72485       };
72486     } catch (std::exception& e) {
72487       {
72488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (...) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72493       };
72494     }
72495   }
72496   jresult = result;
72497   return jresult;
72498 }
72499
72500
72501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72502   unsigned int jresult ;
72503   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72504   float arg2 ;
72505   bool arg3 ;
72506   unsigned int result;
72507
72508   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72509   arg2 = (float)jarg2;
72510   arg3 = jarg3 ? true : false;
72511   {
72512     try {
72513       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72514     } catch (std::out_of_range& e) {
72515       {
72516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72517       };
72518     } catch (std::exception& e) {
72519       {
72520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72525       };
72526     }
72527   }
72528   jresult = result;
72529   return jresult;
72530 }
72531
72532
72533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72534   unsigned int jresult ;
72535   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72536   unsigned int result;
72537
72538   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72539   {
72540     try {
72541       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72542     } catch (std::out_of_range& e) {
72543       {
72544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72545       };
72546     } catch (std::exception& e) {
72547       {
72548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72549       };
72550     } catch (...) {
72551       {
72552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72553       };
72554     }
72555   }
72556   jresult = result;
72557   return jresult;
72558 }
72559
72560
72561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72562   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72563
72564   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72565   {
72566     try {
72567       delete arg1;
72568     } catch (std::out_of_range& e) {
72569       {
72570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72571       };
72572     } catch (std::exception& e) {
72573       {
72574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72575       };
72576     } catch (...) {
72577       {
72578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72579       };
72580     }
72581   }
72582 }
72583
72584
72585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72586   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72587   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72588
72589   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72590   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72591   if (arg1) (arg1)->scale = *arg2;
72592 }
72593
72594
72595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72596   void * jresult ;
72597   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72598   Dali::Toolkit::ClampState2D *result = 0 ;
72599
72600   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72601   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72602   jresult = (void *)result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72608   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72609   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72610
72611   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72612   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72613   if (arg1) (arg1)->position = *arg2;
72614 }
72615
72616
72617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72618   void * jresult ;
72619   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72620   Dali::Toolkit::ClampState2D *result = 0 ;
72621
72622   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72623   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72624   jresult = (void *)result;
72625   return jresult;
72626 }
72627
72628
72629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72630   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72631   Dali::Toolkit::ClampState arg2 ;
72632
72633   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72634   arg2 = (Dali::Toolkit::ClampState)jarg2;
72635   if (arg1) (arg1)->rotation = arg2;
72636 }
72637
72638
72639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72640   int jresult ;
72641   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72642   Dali::Toolkit::ClampState result;
72643
72644   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72645   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72646   jresult = (int)result;
72647   return jresult;
72648 }
72649
72650
72651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72652   void * jresult ;
72653   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72654
72655   {
72656     try {
72657       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72658     } catch (std::out_of_range& e) {
72659       {
72660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72661       };
72662     } catch (std::exception& e) {
72663       {
72664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72665       };
72666     } catch (...) {
72667       {
72668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72669       };
72670     }
72671   }
72672   jresult = (void *)result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72678   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72679
72680   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72681   {
72682     try {
72683       delete arg1;
72684     } catch (std::out_of_range& e) {
72685       {
72686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72687       };
72688     } catch (std::exception& e) {
72689       {
72690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72691       };
72692     } catch (...) {
72693       {
72694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72695       };
72696     }
72697   }
72698 }
72699
72700
72701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72702   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72703   Dali::Toolkit::SnapType arg2 ;
72704
72705   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72706   arg2 = (Dali::Toolkit::SnapType)jarg2;
72707   if (arg1) (arg1)->type = arg2;
72708 }
72709
72710
72711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72712   int jresult ;
72713   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72714   Dali::Toolkit::SnapType result;
72715
72716   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72717   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72718   jresult = (int)result;
72719   return jresult;
72720 }
72721
72722
72723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72724   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72725   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72726
72727   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72728   arg2 = (Dali::Vector2 *)jarg2;
72729   if (arg1) (arg1)->position = *arg2;
72730 }
72731
72732
72733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72734   void * jresult ;
72735   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72736   Dali::Vector2 *result = 0 ;
72737
72738   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72739   result = (Dali::Vector2 *)& ((arg1)->position);
72740   jresult = (void *)result;
72741   return jresult;
72742 }
72743
72744
72745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72746   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72747   float arg2 ;
72748
72749   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72750   arg2 = (float)jarg2;
72751   if (arg1) (arg1)->duration = arg2;
72752 }
72753
72754
72755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72756   float jresult ;
72757   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72758   float result;
72759
72760   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72761   result = (float) ((arg1)->duration);
72762   jresult = result;
72763   return jresult;
72764 }
72765
72766
72767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72768   void * jresult ;
72769   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72770
72771   {
72772     try {
72773       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72774     } catch (std::out_of_range& e) {
72775       {
72776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72777       };
72778     } catch (std::exception& e) {
72779       {
72780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (...) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72785       };
72786     }
72787   }
72788   jresult = (void *)result;
72789   return jresult;
72790 }
72791
72792
72793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72794   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72795
72796   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72797   {
72798     try {
72799       delete arg1;
72800     } catch (std::out_of_range& e) {
72801       {
72802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72803       };
72804     } catch (std::exception& e) {
72805       {
72806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72807       };
72808     } catch (...) {
72809       {
72810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72811       };
72812     }
72813   }
72814 }
72815
72816
72817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72818   int jresult ;
72819   int result;
72820
72821   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72822   jresult = (int)result;
72823   return jresult;
72824 }
72825
72826
72827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72828   int jresult ;
72829   int result;
72830
72831   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72832   jresult = (int)result;
72833   return jresult;
72834 }
72835
72836
72837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72838   int jresult ;
72839   int result;
72840
72841   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72842   jresult = (int)result;
72843   return jresult;
72844 }
72845
72846
72847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72848   int jresult ;
72849   int result;
72850
72851   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72852   jresult = (int)result;
72853   return jresult;
72854 }
72855
72856
72857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
72858   int jresult ;
72859   int result;
72860
72861   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
72862   jresult = (int)result;
72863   return jresult;
72864 }
72865
72866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72867   int jresult ;
72868   int result;
72869
72870   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72871   jresult = (int)result;
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72877   int jresult ;
72878   int result;
72879
72880   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72881   jresult = (int)result;
72882   return jresult;
72883 }
72884
72885
72886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72887   int jresult ;
72888   int result;
72889
72890   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72891   jresult = (int)result;
72892   return jresult;
72893 }
72894
72895
72896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72897   int jresult ;
72898   int result;
72899
72900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72901   jresult = (int)result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72907   int jresult ;
72908   int result;
72909
72910   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72911   jresult = (int)result;
72912   return jresult;
72913 }
72914
72915
72916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72917   int jresult ;
72918   int result;
72919
72920   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72921   jresult = (int)result;
72922   return jresult;
72923 }
72924
72925
72926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72927   int jresult ;
72928   int result;
72929
72930   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72931   jresult = (int)result;
72932   return jresult;
72933 }
72934
72935
72936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72937   int jresult ;
72938   int result;
72939
72940   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72941   jresult = (int)result;
72942   return jresult;
72943 }
72944
72945
72946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72947   int jresult ;
72948   int result;
72949
72950   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72951   jresult = (int)result;
72952   return jresult;
72953 }
72954
72955
72956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72957   int jresult ;
72958   int result;
72959
72960   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72961   jresult = (int)result;
72962   return jresult;
72963 }
72964
72965
72966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72967   int jresult ;
72968   int result;
72969
72970   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72971   jresult = (int)result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72977   int jresult ;
72978   int result;
72979
72980   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72981   jresult = (int)result;
72982   return jresult;
72983 }
72984
72985
72986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72987   int jresult ;
72988   int result;
72989
72990   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72991   jresult = (int)result;
72992   return jresult;
72993 }
72994
72995
72996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72997   int jresult ;
72998   int result;
72999
73000   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73001   jresult = (int)result;
73002   return jresult;
73003 }
73004
73005
73006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73007   int jresult ;
73008   int result;
73009
73010   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73011   jresult = (int)result;
73012   return jresult;
73013 }
73014
73015
73016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73017   int jresult ;
73018   int result;
73019
73020   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73021   jresult = (int)result;
73022   return jresult;
73023 }
73024
73025
73026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73027   int jresult ;
73028   int result;
73029
73030   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73031   jresult = (int)result;
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73037   int jresult ;
73038   int result;
73039
73040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73041   jresult = (int)result;
73042   return jresult;
73043 }
73044
73045
73046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73047   int jresult ;
73048   int result;
73049
73050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73051   jresult = (int)result;
73052   return jresult;
73053 }
73054
73055
73056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73057   int jresult ;
73058   int result;
73059
73060   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73061   jresult = (int)result;
73062   return jresult;
73063 }
73064
73065
73066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73067   int jresult ;
73068   int result;
73069
73070   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73071   jresult = (int)result;
73072   return jresult;
73073 }
73074
73075
73076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73077   void * jresult ;
73078   Dali::Toolkit::ScrollView::Property *result = 0 ;
73079
73080   {
73081     try {
73082       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73083     } catch (std::out_of_range& e) {
73084       {
73085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73086       };
73087     } catch (std::exception& e) {
73088       {
73089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (...) {
73092       {
73093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73094       };
73095     }
73096   }
73097   jresult = (void *)result;
73098   return jresult;
73099 }
73100
73101
73102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73103   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73104
73105   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73106   {
73107     try {
73108       delete arg1;
73109     } catch (std::out_of_range& e) {
73110       {
73111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73112       };
73113     } catch (std::exception& e) {
73114       {
73115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73116       };
73117     } catch (...) {
73118       {
73119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73120       };
73121     }
73122   }
73123 }
73124
73125
73126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73127   void * jresult ;
73128   Dali::Toolkit::ScrollView *result = 0 ;
73129
73130   {
73131     try {
73132       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73133     } catch (std::out_of_range& e) {
73134       {
73135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (std::exception& e) {
73138       {
73139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73140       };
73141     } catch (...) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73144       };
73145     }
73146   }
73147   jresult = (void *)result;
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73153   void * jresult ;
73154   Dali::Toolkit::ScrollView *arg1 = 0 ;
73155   Dali::Toolkit::ScrollView *result = 0 ;
73156
73157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73158   if (!arg1) {
73159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73160     return 0;
73161   }
73162   {
73163     try {
73164       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73165     } catch (std::out_of_range& e) {
73166       {
73167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73168       };
73169     } catch (std::exception& e) {
73170       {
73171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73172       };
73173     } catch (...) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73176       };
73177     }
73178   }
73179   jresult = (void *)result;
73180   return jresult;
73181 }
73182
73183
73184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73185   void * jresult ;
73186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73187   Dali::Toolkit::ScrollView *arg2 = 0 ;
73188   Dali::Toolkit::ScrollView *result = 0 ;
73189
73190   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73191   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73192   if (!arg2) {
73193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73194     return 0;
73195   }
73196   {
73197     try {
73198       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73199     } catch (std::out_of_range& e) {
73200       {
73201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73202       };
73203     } catch (std::exception& e) {
73204       {
73205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73206       };
73207     } catch (...) {
73208       {
73209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73210       };
73211     }
73212   }
73213   jresult = (void *)result;
73214   return jresult;
73215 }
73216
73217
73218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73219   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73220
73221   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73222   {
73223     try {
73224       delete arg1;
73225     } catch (std::out_of_range& e) {
73226       {
73227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73228       };
73229     } catch (std::exception& e) {
73230       {
73231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73232       };
73233     } catch (...) {
73234       {
73235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73236       };
73237     }
73238   }
73239 }
73240
73241
73242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73243   void * jresult ;
73244   Dali::Toolkit::ScrollView result;
73245
73246   {
73247     try {
73248       result = Dali::Toolkit::ScrollView::New();
73249     } catch (std::out_of_range& e) {
73250       {
73251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73252       };
73253     } catch (std::exception& e) {
73254       {
73255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73256       };
73257     } catch (...) {
73258       {
73259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73260       };
73261     }
73262   }
73263   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73264   return jresult;
73265 }
73266
73267
73268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73269   void * jresult ;
73270   Dali::BaseHandle arg1 ;
73271   Dali::BaseHandle *argp1 ;
73272   Dali::Toolkit::ScrollView result;
73273
73274   argp1 = (Dali::BaseHandle *)jarg1;
73275   if (!argp1) {
73276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73277     return 0;
73278   }
73279   arg1 = *argp1;
73280   {
73281     try {
73282       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (...) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73294       };
73295     }
73296   }
73297   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73298   return jresult;
73299 }
73300
73301
73302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73303   void * jresult ;
73304   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73305   Dali::AlphaFunction result;
73306
73307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73308   {
73309     try {
73310       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73311     } catch (std::out_of_range& e) {
73312       {
73313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73314       };
73315     } catch (std::exception& e) {
73316       {
73317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73318       };
73319     } catch (...) {
73320       {
73321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73322       };
73323     }
73324   }
73325   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73326   return jresult;
73327 }
73328
73329
73330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73331   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73332   Dali::AlphaFunction arg2 ;
73333   Dali::AlphaFunction *argp2 ;
73334
73335   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73336   argp2 = (Dali::AlphaFunction *)jarg2;
73337   if (!argp2) {
73338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73339     return ;
73340   }
73341   arg2 = *argp2;
73342   {
73343     try {
73344       (arg1)->SetScrollSnapAlphaFunction(arg2);
73345     } catch (std::out_of_range& e) {
73346       {
73347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73348       };
73349     } catch (std::exception& e) {
73350       {
73351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73352       };
73353     } catch (...) {
73354       {
73355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73356       };
73357     }
73358   }
73359 }
73360
73361
73362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73363   void * jresult ;
73364   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73365   Dali::AlphaFunction result;
73366
73367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73368   {
73369     try {
73370       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73371     } catch (std::out_of_range& e) {
73372       {
73373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73374       };
73375     } catch (std::exception& e) {
73376       {
73377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73378       };
73379     } catch (...) {
73380       {
73381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73382       };
73383     }
73384   }
73385   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73386   return jresult;
73387 }
73388
73389
73390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73391   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73392   Dali::AlphaFunction arg2 ;
73393   Dali::AlphaFunction *argp2 ;
73394
73395   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73396   argp2 = (Dali::AlphaFunction *)jarg2;
73397   if (!argp2) {
73398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73399     return ;
73400   }
73401   arg2 = *argp2;
73402   {
73403     try {
73404       (arg1)->SetScrollFlickAlphaFunction(arg2);
73405     } catch (std::out_of_range& e) {
73406       {
73407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73408       };
73409     } catch (std::exception& e) {
73410       {
73411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73412       };
73413     } catch (...) {
73414       {
73415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73416       };
73417     }
73418   }
73419 }
73420
73421
73422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73423   float jresult ;
73424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73425   float result;
73426
73427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73428   {
73429     try {
73430       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73431     } catch (std::out_of_range& e) {
73432       {
73433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73434       };
73435     } catch (std::exception& e) {
73436       {
73437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73438       };
73439     } catch (...) {
73440       {
73441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73442       };
73443     }
73444   }
73445   jresult = result;
73446   return jresult;
73447 }
73448
73449
73450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73451   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73452   float arg2 ;
73453
73454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73455   arg2 = (float)jarg2;
73456   {
73457     try {
73458       (arg1)->SetScrollSnapDuration(arg2);
73459     } catch (std::out_of_range& e) {
73460       {
73461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73462       };
73463     } catch (std::exception& e) {
73464       {
73465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73466       };
73467     } catch (...) {
73468       {
73469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73470       };
73471     }
73472   }
73473 }
73474
73475
73476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73477   float jresult ;
73478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73479   float result;
73480
73481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73482   {
73483     try {
73484       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73485     } catch (std::out_of_range& e) {
73486       {
73487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73488       };
73489     } catch (std::exception& e) {
73490       {
73491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73492       };
73493     } catch (...) {
73494       {
73495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73496       };
73497     }
73498   }
73499   jresult = result;
73500   return jresult;
73501 }
73502
73503
73504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73506   float arg2 ;
73507
73508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73509   arg2 = (float)jarg2;
73510   {
73511     try {
73512       (arg1)->SetScrollFlickDuration(arg2);
73513     } catch (std::out_of_range& e) {
73514       {
73515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73516       };
73517     } catch (std::exception& e) {
73518       {
73519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73520       };
73521     } catch (...) {
73522       {
73523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73524       };
73525     }
73526   }
73527 }
73528
73529
73530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73532   Dali::Toolkit::RulerPtr arg2 ;
73533   Dali::Toolkit::RulerPtr *argp2 ;
73534
73535   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73536   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73537   if (!argp2) {
73538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73539     return ;
73540   }
73541   arg2 = *argp2;
73542   {
73543     try {
73544       (arg1)->SetRulerX(arg2);
73545     } catch (std::out_of_range& e) {
73546       {
73547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73548       };
73549     } catch (std::exception& e) {
73550       {
73551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73552       };
73553     } catch (...) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73556       };
73557     }
73558   }
73559 }
73560
73561
73562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73564   Dali::Toolkit::RulerPtr arg2 ;
73565   Dali::Toolkit::RulerPtr *argp2 ;
73566
73567   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73568   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73569   if (!argp2) {
73570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73571     return ;
73572   }
73573   arg2 = *argp2;
73574   {
73575     try {
73576       (arg1)->SetRulerY(arg2);
73577     } catch (std::out_of_range& e) {
73578       {
73579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73580       };
73581     } catch (std::exception& e) {
73582       {
73583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73584       };
73585     } catch (...) {
73586       {
73587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73588       };
73589     }
73590   }
73591 }
73592
73593
73594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73595   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73596   bool arg2 ;
73597
73598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73599   arg2 = jarg2 ? true : false;
73600   {
73601     try {
73602       (arg1)->SetScrollSensitive(arg2);
73603     } catch (std::out_of_range& e) {
73604       {
73605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73606       };
73607     } catch (std::exception& e) {
73608       {
73609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73610       };
73611     } catch (...) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73614       };
73615     }
73616   }
73617 }
73618
73619
73620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73622   float arg2 ;
73623   float arg3 ;
73624
73625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73626   arg2 = (float)jarg2;
73627   arg3 = (float)jarg3;
73628   {
73629     try {
73630       (arg1)->SetMaxOvershoot(arg2,arg3);
73631     } catch (std::out_of_range& e) {
73632       {
73633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73634       };
73635     } catch (std::exception& e) {
73636       {
73637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73638       };
73639     } catch (...) {
73640       {
73641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73642       };
73643     }
73644   }
73645 }
73646
73647
73648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73650   Dali::AlphaFunction arg2 ;
73651   Dali::AlphaFunction *argp2 ;
73652
73653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73654   argp2 = (Dali::AlphaFunction *)jarg2;
73655   if (!argp2) {
73656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73657     return ;
73658   }
73659   arg2 = *argp2;
73660   {
73661     try {
73662       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73663     } catch (std::out_of_range& e) {
73664       {
73665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73666       };
73667     } catch (std::exception& e) {
73668       {
73669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73670       };
73671     } catch (...) {
73672       {
73673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73674       };
73675     }
73676   }
73677 }
73678
73679
73680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73681   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73682   float arg2 ;
73683
73684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73685   arg2 = (float)jarg2;
73686   {
73687     try {
73688       (arg1)->SetSnapOvershootDuration(arg2);
73689     } catch (std::out_of_range& e) {
73690       {
73691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73692       };
73693     } catch (std::exception& e) {
73694       {
73695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73696       };
73697     } catch (...) {
73698       {
73699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73700       };
73701     }
73702   }
73703 }
73704
73705
73706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73708   bool arg2 ;
73709
73710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73711   arg2 = jarg2 ? true : false;
73712   {
73713     try {
73714       (arg1)->SetActorAutoSnap(arg2);
73715     } catch (std::out_of_range& e) {
73716       {
73717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73718       };
73719     } catch (std::exception& e) {
73720       {
73721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73722       };
73723     } catch (...) {
73724       {
73725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73726       };
73727     }
73728   }
73729 }
73730
73731
73732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73734   bool arg2 ;
73735
73736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73737   arg2 = jarg2 ? true : false;
73738   {
73739     try {
73740       (arg1)->SetWrapMode(arg2);
73741     } catch (std::out_of_range& e) {
73742       {
73743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73744       };
73745     } catch (std::exception& e) {
73746       {
73747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73748       };
73749     } catch (...) {
73750       {
73751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73752       };
73753     }
73754   }
73755 }
73756
73757
73758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73759   int jresult ;
73760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73761   int result;
73762
73763   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73764   {
73765     try {
73766       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73767     } catch (std::out_of_range& e) {
73768       {
73769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73770       };
73771     } catch (std::exception& e) {
73772       {
73773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73774       };
73775     } catch (...) {
73776       {
73777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73778       };
73779     }
73780   }
73781   jresult = result;
73782   return jresult;
73783 }
73784
73785
73786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73788   int arg2 ;
73789
73790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73791   arg2 = (int)jarg2;
73792   {
73793     try {
73794       (arg1)->SetScrollUpdateDistance(arg2);
73795     } catch (std::out_of_range& e) {
73796       {
73797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73798       };
73799     } catch (std::exception& e) {
73800       {
73801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73802       };
73803     } catch (...) {
73804       {
73805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73806       };
73807     }
73808   }
73809 }
73810
73811
73812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73813   unsigned int jresult ;
73814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73815   bool result;
73816
73817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73818   {
73819     try {
73820       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73821     } catch (std::out_of_range& e) {
73822       {
73823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (std::exception& e) {
73826       {
73827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73828       };
73829     } catch (...) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73832       };
73833     }
73834   }
73835   jresult = result;
73836   return jresult;
73837 }
73838
73839
73840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73842   bool arg2 ;
73843
73844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73845   arg2 = jarg2 ? true : false;
73846   {
73847     try {
73848       (arg1)->SetAxisAutoLock(arg2);
73849     } catch (std::out_of_range& e) {
73850       {
73851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73852       };
73853     } catch (std::exception& e) {
73854       {
73855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73856       };
73857     } catch (...) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73860       };
73861     }
73862   }
73863 }
73864
73865
73866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73867   float jresult ;
73868   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73869   float result;
73870
73871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73872   {
73873     try {
73874       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73875     } catch (std::out_of_range& e) {
73876       {
73877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73878       };
73879     } catch (std::exception& e) {
73880       {
73881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73882       };
73883     } catch (...) {
73884       {
73885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73886       };
73887     }
73888   }
73889   jresult = result;
73890   return jresult;
73891 }
73892
73893
73894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73896   float arg2 ;
73897
73898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73899   arg2 = (float)jarg2;
73900   {
73901     try {
73902       (arg1)->SetAxisAutoLockGradient(arg2);
73903     } catch (std::out_of_range& e) {
73904       {
73905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73906       };
73907     } catch (std::exception& e) {
73908       {
73909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73910       };
73911     } catch (...) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73914       };
73915     }
73916   }
73917 }
73918
73919
73920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73921   float jresult ;
73922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73923   float result;
73924
73925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73926   {
73927     try {
73928       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73929     } catch (std::out_of_range& e) {
73930       {
73931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73932       };
73933     } catch (std::exception& e) {
73934       {
73935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73936       };
73937     } catch (...) {
73938       {
73939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73940       };
73941     }
73942   }
73943   jresult = result;
73944   return jresult;
73945 }
73946
73947
73948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73949   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73950   float arg2 ;
73951
73952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73953   arg2 = (float)jarg2;
73954   {
73955     try {
73956       (arg1)->SetFrictionCoefficient(arg2);
73957     } catch (std::out_of_range& e) {
73958       {
73959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73960       };
73961     } catch (std::exception& e) {
73962       {
73963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73964       };
73965     } catch (...) {
73966       {
73967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73968       };
73969     }
73970   }
73971 }
73972
73973
73974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73975   float jresult ;
73976   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73977   float result;
73978
73979   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73980   {
73981     try {
73982       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73983     } catch (std::out_of_range& e) {
73984       {
73985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73986       };
73987     } catch (std::exception& e) {
73988       {
73989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73990       };
73991     } catch (...) {
73992       {
73993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73994       };
73995     }
73996   }
73997   jresult = result;
73998   return jresult;
73999 }
74000
74001
74002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74003   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74004   float arg2 ;
74005
74006   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74007   arg2 = (float)jarg2;
74008   {
74009     try {
74010       (arg1)->SetFlickSpeedCoefficient(arg2);
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74018       };
74019     } catch (...) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74022       };
74023     }
74024   }
74025 }
74026
74027
74028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74029   void * jresult ;
74030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74031   Dali::Vector2 result;
74032
74033   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74034   {
74035     try {
74036       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74037     } catch (std::out_of_range& e) {
74038       {
74039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74040       };
74041     } catch (std::exception& e) {
74042       {
74043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (...) {
74046       {
74047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74048       };
74049     }
74050   }
74051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74052   return jresult;
74053 }
74054
74055
74056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74058   Dali::Vector2 *arg2 = 0 ;
74059
74060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74061   arg2 = (Dali::Vector2 *)jarg2;
74062   if (!arg2) {
74063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74064     return ;
74065   }
74066   {
74067     try {
74068       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74069     } catch (std::out_of_range& e) {
74070       {
74071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74072       };
74073     } catch (std::exception& e) {
74074       {
74075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74076       };
74077     } catch (...) {
74078       {
74079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74080       };
74081     }
74082   }
74083 }
74084
74085
74086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74087   float jresult ;
74088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74089   float result;
74090
74091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74092   {
74093     try {
74094       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74095     } catch (std::out_of_range& e) {
74096       {
74097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74098       };
74099     } catch (std::exception& e) {
74100       {
74101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74102       };
74103     } catch (...) {
74104       {
74105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74106       };
74107     }
74108   }
74109   jresult = result;
74110   return jresult;
74111 }
74112
74113
74114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74116   float arg2 ;
74117
74118   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74119   arg2 = (float)jarg2;
74120   {
74121     try {
74122       (arg1)->SetMinimumSpeedForFlick(arg2);
74123     } catch (std::out_of_range& e) {
74124       {
74125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74126       };
74127     } catch (std::exception& e) {
74128       {
74129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74130       };
74131     } catch (...) {
74132       {
74133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74134       };
74135     }
74136   }
74137 }
74138
74139
74140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74141   float jresult ;
74142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74143   float result;
74144
74145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74146   {
74147     try {
74148       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74149     } catch (std::out_of_range& e) {
74150       {
74151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74152       };
74153     } catch (std::exception& e) {
74154       {
74155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74156       };
74157     } catch (...) {
74158       {
74159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74160       };
74161     }
74162   }
74163   jresult = result;
74164   return jresult;
74165 }
74166
74167
74168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74170   float arg2 ;
74171
74172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74173   arg2 = (float)jarg2;
74174   {
74175     try {
74176       (arg1)->SetMaxFlickSpeed(arg2);
74177     } catch (std::out_of_range& e) {
74178       {
74179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74180       };
74181     } catch (std::exception& e) {
74182       {
74183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74184       };
74185     } catch (...) {
74186       {
74187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74188       };
74189     }
74190   }
74191 }
74192
74193
74194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74195   void * jresult ;
74196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74197   Dali::Vector2 result;
74198
74199   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74200   {
74201     try {
74202       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74203     } catch (std::out_of_range& e) {
74204       {
74205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74206       };
74207     } catch (std::exception& e) {
74208       {
74209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74210       };
74211     } catch (...) {
74212       {
74213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74214       };
74215     }
74216   }
74217   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74218   return jresult;
74219 }
74220
74221
74222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74223   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74224   Dali::Vector2 arg2 ;
74225   Dali::Vector2 *argp2 ;
74226
74227   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74228   argp2 = (Dali::Vector2 *)jarg2;
74229   if (!argp2) {
74230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74231     return ;
74232   }
74233   arg2 = *argp2;
74234   {
74235     try {
74236       (arg1)->SetWheelScrollDistanceStep(arg2);
74237     } catch (std::out_of_range& e) {
74238       {
74239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74240       };
74241     } catch (std::exception& e) {
74242       {
74243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74244       };
74245     } catch (...) {
74246       {
74247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74248       };
74249     }
74250   }
74251 }
74252
74253
74254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74255   void * jresult ;
74256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74257   Dali::Vector2 result;
74258
74259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74260   {
74261     try {
74262       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74263     } catch (std::out_of_range& e) {
74264       {
74265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74266       };
74267     } catch (std::exception& e) {
74268       {
74269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (...) {
74272       {
74273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74274       };
74275     }
74276   }
74277   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74278   return jresult;
74279 }
74280
74281
74282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74283   unsigned int jresult ;
74284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74285   unsigned int result;
74286
74287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74288   {
74289     try {
74290       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74291     } catch (std::out_of_range& e) {
74292       {
74293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74294       };
74295     } catch (std::exception& e) {
74296       {
74297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74298       };
74299     } catch (...) {
74300       {
74301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74302       };
74303     }
74304   }
74305   jresult = result;
74306   return jresult;
74307 }
74308
74309
74310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74312   Dali::Vector2 *arg2 = 0 ;
74313
74314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74315   arg2 = (Dali::Vector2 *)jarg2;
74316   if (!arg2) {
74317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74318     return ;
74319   }
74320   {
74321     try {
74322       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74323     } catch (std::out_of_range& e) {
74324       {
74325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74326       };
74327     } catch (std::exception& e) {
74328       {
74329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74330       };
74331     } catch (...) {
74332       {
74333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74334       };
74335     }
74336   }
74337 }
74338
74339
74340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74342   Dali::Vector2 *arg2 = 0 ;
74343   float arg3 ;
74344
74345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74346   arg2 = (Dali::Vector2 *)jarg2;
74347   if (!arg2) {
74348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74349     return ;
74350   }
74351   arg3 = (float)jarg3;
74352   {
74353     try {
74354       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74362       };
74363     } catch (...) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74366       };
74367     }
74368   }
74369 }
74370
74371
74372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74374   Dali::Vector2 *arg2 = 0 ;
74375   float arg3 ;
74376   Dali::AlphaFunction arg4 ;
74377   Dali::AlphaFunction *argp4 ;
74378
74379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74380   arg2 = (Dali::Vector2 *)jarg2;
74381   if (!arg2) {
74382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74383     return ;
74384   }
74385   arg3 = (float)jarg3;
74386   argp4 = (Dali::AlphaFunction *)jarg4;
74387   if (!argp4) {
74388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74389     return ;
74390   }
74391   arg4 = *argp4;
74392   {
74393     try {
74394       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74395     } catch (std::out_of_range& e) {
74396       {
74397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74398       };
74399     } catch (std::exception& e) {
74400       {
74401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74402       };
74403     } catch (...) {
74404       {
74405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74406       };
74407     }
74408   }
74409 }
74410
74411
74412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74414   Dali::Vector2 *arg2 = 0 ;
74415   float arg3 ;
74416   Dali::Toolkit::DirectionBias arg4 ;
74417   Dali::Toolkit::DirectionBias arg5 ;
74418
74419   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74420   arg2 = (Dali::Vector2 *)jarg2;
74421   if (!arg2) {
74422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74423     return ;
74424   }
74425   arg3 = (float)jarg3;
74426   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74427   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74428   {
74429     try {
74430       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74431     } catch (std::out_of_range& e) {
74432       {
74433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74434       };
74435     } catch (std::exception& e) {
74436       {
74437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74438       };
74439     } catch (...) {
74440       {
74441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74442       };
74443     }
74444   }
74445 }
74446
74447
74448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74450   Dali::Vector2 *arg2 = 0 ;
74451   float arg3 ;
74452   Dali::AlphaFunction arg4 ;
74453   Dali::Toolkit::DirectionBias arg5 ;
74454   Dali::Toolkit::DirectionBias arg6 ;
74455   Dali::AlphaFunction *argp4 ;
74456
74457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74458   arg2 = (Dali::Vector2 *)jarg2;
74459   if (!arg2) {
74460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74461     return ;
74462   }
74463   arg3 = (float)jarg3;
74464   argp4 = (Dali::AlphaFunction *)jarg4;
74465   if (!argp4) {
74466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74467     return ;
74468   }
74469   arg4 = *argp4;
74470   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74471   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74472   {
74473     try {
74474       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74475     } catch (std::out_of_range& e) {
74476       {
74477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74478       };
74479     } catch (std::exception& e) {
74480       {
74481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74482       };
74483     } catch (...) {
74484       {
74485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74486       };
74487     }
74488   }
74489 }
74490
74491
74492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74494   unsigned int arg2 ;
74495
74496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74497   arg2 = (unsigned int)jarg2;
74498   {
74499     try {
74500       (arg1)->ScrollTo(arg2);
74501     } catch (std::out_of_range& e) {
74502       {
74503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74504       };
74505     } catch (std::exception& e) {
74506       {
74507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74508       };
74509     } catch (...) {
74510       {
74511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74512       };
74513     }
74514   }
74515 }
74516
74517
74518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74519   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74520   unsigned int arg2 ;
74521   float arg3 ;
74522
74523   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74524   arg2 = (unsigned int)jarg2;
74525   arg3 = (float)jarg3;
74526   {
74527     try {
74528       (arg1)->ScrollTo(arg2,arg3);
74529     } catch (std::out_of_range& e) {
74530       {
74531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (std::exception& e) {
74534       {
74535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74540       };
74541     }
74542   }
74543 }
74544
74545
74546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74548   unsigned int arg2 ;
74549   float arg3 ;
74550   Dali::Toolkit::DirectionBias arg4 ;
74551
74552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74553   arg2 = (unsigned int)jarg2;
74554   arg3 = (float)jarg3;
74555   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74556   {
74557     try {
74558       (arg1)->ScrollTo(arg2,arg3,arg4);
74559     } catch (std::out_of_range& e) {
74560       {
74561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74562       };
74563     } catch (std::exception& e) {
74564       {
74565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74570       };
74571     }
74572   }
74573 }
74574
74575
74576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74577   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74578   Dali::Actor *arg2 = 0 ;
74579
74580   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74581   arg2 = (Dali::Actor *)jarg2;
74582   if (!arg2) {
74583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74584     return ;
74585   }
74586   {
74587     try {
74588       (arg1)->ScrollTo(*arg2);
74589     } catch (std::out_of_range& e) {
74590       {
74591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74592       };
74593     } catch (std::exception& e) {
74594       {
74595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74596       };
74597     } catch (...) {
74598       {
74599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74600       };
74601     }
74602   }
74603 }
74604
74605
74606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74608   Dali::Actor *arg2 = 0 ;
74609   float arg3 ;
74610
74611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74612   arg2 = (Dali::Actor *)jarg2;
74613   if (!arg2) {
74614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74615     return ;
74616   }
74617   arg3 = (float)jarg3;
74618   {
74619     try {
74620       (arg1)->ScrollTo(*arg2,arg3);
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74628       };
74629     } catch (...) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74632       };
74633     }
74634   }
74635 }
74636
74637
74638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74639   unsigned int jresult ;
74640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74641   bool result;
74642
74643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74644   {
74645     try {
74646       result = (bool)(arg1)->ScrollToSnapPoint();
74647     } catch (std::out_of_range& e) {
74648       {
74649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74650       };
74651     } catch (std::exception& e) {
74652       {
74653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74654       };
74655     } catch (...) {
74656       {
74657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74658       };
74659     }
74660   }
74661   jresult = result;
74662   return jresult;
74663 }
74664
74665
74666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74668   Dali::Constraint arg2 ;
74669   Dali::Constraint *argp2 ;
74670
74671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74672   argp2 = (Dali::Constraint *)jarg2;
74673   if (!argp2) {
74674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74675     return ;
74676   }
74677   arg2 = *argp2;
74678   {
74679     try {
74680       (arg1)->ApplyConstraintToChildren(arg2);
74681     } catch (std::out_of_range& e) {
74682       {
74683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74684       };
74685     } catch (std::exception& e) {
74686       {
74687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74688       };
74689     } catch (...) {
74690       {
74691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74692       };
74693     }
74694   }
74695 }
74696
74697
74698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74700
74701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74702   {
74703     try {
74704       (arg1)->RemoveConstraintsFromChildren();
74705     } catch (std::out_of_range& e) {
74706       {
74707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74708       };
74709     } catch (std::exception& e) {
74710       {
74711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74712       };
74713     } catch (...) {
74714       {
74715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74716       };
74717     }
74718   }
74719 }
74720
74721
74722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74723   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74724   Dali::Toolkit::ScrollViewEffect arg2 ;
74725   Dali::Toolkit::ScrollViewEffect *argp2 ;
74726
74727   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74728   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74729   if (!argp2) {
74730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74731     return ;
74732   }
74733   arg2 = *argp2;
74734   {
74735     try {
74736       (arg1)->ApplyEffect(arg2);
74737     } catch (std::out_of_range& e) {
74738       {
74739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74740       };
74741     } catch (std::exception& e) {
74742       {
74743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74744       };
74745     } catch (...) {
74746       {
74747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74748       };
74749     }
74750   }
74751 }
74752
74753
74754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74755   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74756   Dali::Toolkit::ScrollViewEffect arg2 ;
74757   Dali::Toolkit::ScrollViewEffect *argp2 ;
74758
74759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74760   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74761   if (!argp2) {
74762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74763     return ;
74764   }
74765   arg2 = *argp2;
74766   {
74767     try {
74768       (arg1)->RemoveEffect(arg2);
74769     } catch (std::out_of_range& e) {
74770       {
74771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74772       };
74773     } catch (std::exception& e) {
74774       {
74775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74776       };
74777     } catch (...) {
74778       {
74779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74780       };
74781     }
74782   }
74783 }
74784
74785
74786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74788
74789   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74790   {
74791     try {
74792       (arg1)->RemoveAllEffects();
74793     } catch (std::out_of_range& e) {
74794       {
74795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74796       };
74797     } catch (std::exception& e) {
74798       {
74799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74800       };
74801     } catch (...) {
74802       {
74803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74804       };
74805     }
74806   }
74807 }
74808
74809
74810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74811   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74812   Dali::Actor arg2 ;
74813   Dali::Actor *argp2 ;
74814
74815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74816   argp2 = (Dali::Actor *)jarg2;
74817   if (!argp2) {
74818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74819     return ;
74820   }
74821   arg2 = *argp2;
74822   {
74823     try {
74824       (arg1)->BindActor(arg2);
74825     } catch (std::out_of_range& e) {
74826       {
74827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74828       };
74829     } catch (std::exception& e) {
74830       {
74831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74832       };
74833     } catch (...) {
74834       {
74835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74836       };
74837     }
74838   }
74839 }
74840
74841
74842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74844   Dali::Actor arg2 ;
74845   Dali::Actor *argp2 ;
74846
74847   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74848   argp2 = (Dali::Actor *)jarg2;
74849   if (!argp2) {
74850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74851     return ;
74852   }
74853   arg2 = *argp2;
74854   {
74855     try {
74856       (arg1)->UnbindActor(arg2);
74857     } catch (std::out_of_range& e) {
74858       {
74859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74860       };
74861     } catch (std::exception& e) {
74862       {
74863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74864       };
74865     } catch (...) {
74866       {
74867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74868       };
74869     }
74870   }
74871 }
74872
74873
74874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74875   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74876   Dali::Radian arg2 ;
74877   Dali::Radian arg3 ;
74878   Dali::Radian *argp2 ;
74879   Dali::Radian *argp3 ;
74880
74881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74882   argp2 = (Dali::Radian *)jarg2;
74883   if (!argp2) {
74884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74885     return ;
74886   }
74887   arg2 = *argp2;
74888   argp3 = (Dali::Radian *)jarg3;
74889   if (!argp3) {
74890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74891     return ;
74892   }
74893   arg3 = *argp3;
74894   {
74895     try {
74896       (arg1)->SetScrollingDirection(arg2,arg3);
74897     } catch (std::out_of_range& e) {
74898       {
74899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74900       };
74901     } catch (std::exception& e) {
74902       {
74903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74904       };
74905     } catch (...) {
74906       {
74907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74908       };
74909     }
74910   }
74911 }
74912
74913
74914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74916   Dali::Radian arg2 ;
74917   Dali::Radian *argp2 ;
74918
74919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74920   argp2 = (Dali::Radian *)jarg2;
74921   if (!argp2) {
74922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74923     return ;
74924   }
74925   arg2 = *argp2;
74926   {
74927     try {
74928       (arg1)->SetScrollingDirection(arg2);
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74936       };
74937     } catch (...) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74940       };
74941     }
74942   }
74943 }
74944
74945
74946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74948   Dali::Radian arg2 ;
74949   Dali::Radian *argp2 ;
74950
74951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74952   argp2 = (Dali::Radian *)jarg2;
74953   if (!argp2) {
74954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74955     return ;
74956   }
74957   arg2 = *argp2;
74958   {
74959     try {
74960       (arg1)->RemoveScrollingDirection(arg2);
74961     } catch (std::out_of_range& e) {
74962       {
74963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74964       };
74965     } catch (std::exception& e) {
74966       {
74967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (...) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74972       };
74973     }
74974   }
74975 }
74976
74977
74978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74979   void * jresult ;
74980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74981   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74982
74983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74984   {
74985     try {
74986       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74987     } catch (std::out_of_range& e) {
74988       {
74989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74990       };
74991     } catch (std::exception& e) {
74992       {
74993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74994       };
74995     } catch (...) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74998       };
74999     }
75000   }
75001   jresult = (void *)result;
75002   return jresult;
75003 }
75004
75005
75006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75007   int jresult ;
75008   int result;
75009
75010   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75011   jresult = (int)result;
75012   return jresult;
75013 }
75014
75015
75016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75017   int jresult ;
75018   int result;
75019
75020   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75021   jresult = (int)result;
75022   return jresult;
75023 }
75024
75025
75026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75027   int jresult ;
75028   int result;
75029
75030   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75031   jresult = (int)result;
75032   return jresult;
75033 }
75034
75035
75036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75037   int jresult ;
75038   int result;
75039
75040   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75041   jresult = (int)result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75047   int jresult ;
75048   int result;
75049
75050   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75051   jresult = (int)result;
75052   return jresult;
75053 }
75054
75055
75056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75057   void * jresult ;
75058   Dali::Toolkit::TableView::Property *result = 0 ;
75059
75060   {
75061     try {
75062       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75063     } catch (std::out_of_range& e) {
75064       {
75065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75066       };
75067     } catch (std::exception& e) {
75068       {
75069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (...) {
75072       {
75073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75074       };
75075     }
75076   }
75077   jresult = (void *)result;
75078   return jresult;
75079 }
75080
75081
75082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75083   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75084
75085   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75086   {
75087     try {
75088       delete arg1;
75089     } catch (std::out_of_range& e) {
75090       {
75091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75092       };
75093     } catch (std::exception& e) {
75094       {
75095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75096       };
75097     } catch (...) {
75098       {
75099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75100       };
75101     }
75102   }
75103 }
75104
75105
75106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75107   int jresult ;
75108   int result;
75109
75110   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75111   jresult = (int)result;
75112   return jresult;
75113 }
75114
75115
75116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75117   int jresult ;
75118   int result;
75119
75120   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75121   jresult = (int)result;
75122   return jresult;
75123 }
75124
75125
75126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75127   int jresult ;
75128   int result;
75129
75130   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75131   jresult = (int)result;
75132   return jresult;
75133 }
75134
75135
75136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75137   int jresult ;
75138   int result;
75139
75140   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75141   jresult = (int)result;
75142   return jresult;
75143 }
75144
75145
75146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75147   int jresult ;
75148   int result;
75149
75150   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75151   jresult = (int)result;
75152   return jresult;
75153 }
75154
75155
75156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75157   void * jresult ;
75158   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75159
75160   {
75161     try {
75162       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75163     } catch (std::out_of_range& e) {
75164       {
75165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75166       };
75167     } catch (std::exception& e) {
75168       {
75169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75174       };
75175     }
75176   }
75177   jresult = (void *)result;
75178   return jresult;
75179 }
75180
75181
75182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75183   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75184
75185   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75186   {
75187     try {
75188       delete arg1;
75189     } catch (std::out_of_range& e) {
75190       {
75191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75192       };
75193     } catch (std::exception& e) {
75194       {
75195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75196       };
75197     } catch (...) {
75198       {
75199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75200       };
75201     }
75202   }
75203 }
75204
75205
75206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75207   void * jresult ;
75208   unsigned int arg1 ;
75209   unsigned int arg2 ;
75210   unsigned int arg3 ;
75211   unsigned int arg4 ;
75212   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75213
75214   arg1 = (unsigned int)jarg1;
75215   arg2 = (unsigned int)jarg2;
75216   arg3 = (unsigned int)jarg3;
75217   arg4 = (unsigned int)jarg4;
75218   {
75219     try {
75220       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75221     } catch (std::out_of_range& e) {
75222       {
75223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (std::exception& e) {
75226       {
75227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235   jresult = (void *)result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75241   void * jresult ;
75242   unsigned int arg1 ;
75243   unsigned int arg2 ;
75244   unsigned int arg3 ;
75245   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75246
75247   arg1 = (unsigned int)jarg1;
75248   arg2 = (unsigned int)jarg2;
75249   arg3 = (unsigned int)jarg3;
75250   {
75251     try {
75252       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75253     } catch (std::out_of_range& e) {
75254       {
75255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75256       };
75257     } catch (std::exception& e) {
75258       {
75259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75260       };
75261     } catch (...) {
75262       {
75263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75264       };
75265     }
75266   }
75267   jresult = (void *)result;
75268   return jresult;
75269 }
75270
75271
75272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75273   void * jresult ;
75274   unsigned int arg1 ;
75275   unsigned int arg2 ;
75276   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75277
75278   arg1 = (unsigned int)jarg1;
75279   arg2 = (unsigned int)jarg2;
75280   {
75281     try {
75282       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (...) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75294       };
75295     }
75296   }
75297   jresult = (void *)result;
75298   return jresult;
75299 }
75300
75301
75302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75303   void * jresult ;
75304   unsigned int arg1 ;
75305   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75306
75307   arg1 = (unsigned int)jarg1;
75308   {
75309     try {
75310       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75311     } catch (std::out_of_range& e) {
75312       {
75313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75314       };
75315     } catch (std::exception& e) {
75316       {
75317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75322       };
75323     }
75324   }
75325   jresult = (void *)result;
75326   return jresult;
75327 }
75328
75329
75330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75331   void * jresult ;
75332   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75333
75334   {
75335     try {
75336       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75337     } catch (std::out_of_range& e) {
75338       {
75339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75340       };
75341     } catch (std::exception& e) {
75342       {
75343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75344       };
75345     } catch (...) {
75346       {
75347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75348       };
75349     }
75350   }
75351   jresult = (void *)result;
75352   return jresult;
75353 }
75354
75355
75356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75357   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75358   unsigned int arg2 ;
75359
75360   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75361   arg2 = (unsigned int)jarg2;
75362   if (arg1) (arg1)->rowIndex = arg2;
75363 }
75364
75365
75366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75367   unsigned int jresult ;
75368   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75369   unsigned int result;
75370
75371   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75372   result = (unsigned int) ((arg1)->rowIndex);
75373   jresult = result;
75374   return jresult;
75375 }
75376
75377
75378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75379   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75380   unsigned int arg2 ;
75381
75382   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75383   arg2 = (unsigned int)jarg2;
75384   if (arg1) (arg1)->columnIndex = arg2;
75385 }
75386
75387
75388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75389   unsigned int jresult ;
75390   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75391   unsigned int result;
75392
75393   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75394   result = (unsigned int) ((arg1)->columnIndex);
75395   jresult = result;
75396   return jresult;
75397 }
75398
75399
75400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75401   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75402   unsigned int arg2 ;
75403
75404   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75405   arg2 = (unsigned int)jarg2;
75406   if (arg1) (arg1)->rowSpan = arg2;
75407 }
75408
75409
75410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75411   unsigned int jresult ;
75412   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75413   unsigned int result;
75414
75415   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75416   result = (unsigned int) ((arg1)->rowSpan);
75417   jresult = result;
75418   return jresult;
75419 }
75420
75421
75422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75423   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75424   unsigned int arg2 ;
75425
75426   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75427   arg2 = (unsigned int)jarg2;
75428   if (arg1) (arg1)->columnSpan = arg2;
75429 }
75430
75431
75432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75433   unsigned int jresult ;
75434   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75435   unsigned int result;
75436
75437   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75438   result = (unsigned int) ((arg1)->columnSpan);
75439   jresult = result;
75440   return jresult;
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75445   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75446
75447   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75448   {
75449     try {
75450       delete arg1;
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75462       };
75463     }
75464   }
75465 }
75466
75467
75468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75469   void * jresult ;
75470   Dali::Toolkit::TableView *result = 0 ;
75471
75472   {
75473     try {
75474       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75475     } catch (std::out_of_range& e) {
75476       {
75477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75478       };
75479     } catch (std::exception& e) {
75480       {
75481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75482       };
75483     } catch (...) {
75484       {
75485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75486       };
75487     }
75488   }
75489   jresult = (void *)result;
75490   return jresult;
75491 }
75492
75493
75494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75495   void * jresult ;
75496   Dali::Toolkit::TableView *arg1 = 0 ;
75497   Dali::Toolkit::TableView *result = 0 ;
75498
75499   arg1 = (Dali::Toolkit::TableView *)jarg1;
75500   if (!arg1) {
75501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75502     return 0;
75503   }
75504   {
75505     try {
75506       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75507     } catch (std::out_of_range& e) {
75508       {
75509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75510       };
75511     } catch (std::exception& e) {
75512       {
75513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75514       };
75515     } catch (...) {
75516       {
75517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75518       };
75519     }
75520   }
75521   jresult = (void *)result;
75522   return jresult;
75523 }
75524
75525
75526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75527   void * jresult ;
75528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75529   Dali::Toolkit::TableView *arg2 = 0 ;
75530   Dali::Toolkit::TableView *result = 0 ;
75531
75532   arg1 = (Dali::Toolkit::TableView *)jarg1;
75533   arg2 = (Dali::Toolkit::TableView *)jarg2;
75534   if (!arg2) {
75535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75536     return 0;
75537   }
75538   {
75539     try {
75540       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75541     } catch (std::out_of_range& e) {
75542       {
75543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75544       };
75545     } catch (std::exception& e) {
75546       {
75547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75548       };
75549     } catch (...) {
75550       {
75551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75552       };
75553     }
75554   }
75555   jresult = (void *)result;
75556   return jresult;
75557 }
75558
75559
75560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75562
75563   arg1 = (Dali::Toolkit::TableView *)jarg1;
75564   {
75565     try {
75566       delete arg1;
75567     } catch (std::out_of_range& e) {
75568       {
75569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75570       };
75571     } catch (std::exception& e) {
75572       {
75573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75574       };
75575     } catch (...) {
75576       {
75577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75578       };
75579     }
75580   }
75581 }
75582
75583
75584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75585   void * jresult ;
75586   unsigned int arg1 ;
75587   unsigned int arg2 ;
75588   Dali::Toolkit::TableView result;
75589
75590   arg1 = (unsigned int)jarg1;
75591   arg2 = (unsigned int)jarg2;
75592   {
75593     try {
75594       result = Dali::Toolkit::TableView::New(arg1,arg2);
75595     } catch (std::out_of_range& e) {
75596       {
75597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (std::exception& e) {
75600       {
75601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75602       };
75603     } catch (...) {
75604       {
75605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75606       };
75607     }
75608   }
75609   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75610   return jresult;
75611 }
75612
75613
75614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75615   void * jresult ;
75616   Dali::BaseHandle arg1 ;
75617   Dali::BaseHandle *argp1 ;
75618   Dali::Toolkit::TableView result;
75619
75620   argp1 = (Dali::BaseHandle *)jarg1;
75621   if (!argp1) {
75622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75623     return 0;
75624   }
75625   arg1 = *argp1;
75626   {
75627     try {
75628       result = Dali::Toolkit::TableView::DownCast(arg1);
75629     } catch (std::out_of_range& e) {
75630       {
75631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75632       };
75633     } catch (std::exception& e) {
75634       {
75635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75636       };
75637     } catch (...) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75640       };
75641     }
75642   }
75643   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75644   return jresult;
75645 }
75646
75647
75648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75649   unsigned int jresult ;
75650   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75651   Dali::Actor arg2 ;
75652   Dali::Toolkit::TableView::CellPosition arg3 ;
75653   Dali::Actor *argp2 ;
75654   Dali::Toolkit::TableView::CellPosition *argp3 ;
75655   bool result;
75656
75657   arg1 = (Dali::Toolkit::TableView *)jarg1;
75658   argp2 = (Dali::Actor *)jarg2;
75659   if (!argp2) {
75660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75661     return 0;
75662   }
75663   arg2 = *argp2;
75664   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75665   if (!argp3) {
75666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75667     return 0;
75668   }
75669   arg3 = *argp3;
75670   {
75671     try {
75672       result = (bool)(arg1)->AddChild(arg2,arg3);
75673     } catch (std::out_of_range& e) {
75674       {
75675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75676       };
75677     } catch (std::exception& e) {
75678       {
75679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75680       };
75681     } catch (...) {
75682       {
75683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75684       };
75685     }
75686   }
75687   jresult = result;
75688   return jresult;
75689 }
75690
75691
75692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75693   void * jresult ;
75694   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75695   Dali::Toolkit::TableView::CellPosition arg2 ;
75696   Dali::Toolkit::TableView::CellPosition *argp2 ;
75697   Dali::Actor result;
75698
75699   arg1 = (Dali::Toolkit::TableView *)jarg1;
75700   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75701   if (!argp2) {
75702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75703     return 0;
75704   }
75705   arg2 = *argp2;
75706   {
75707     try {
75708       result = (arg1)->GetChildAt(arg2);
75709     } catch (std::out_of_range& e) {
75710       {
75711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75712       };
75713     } catch (std::exception& e) {
75714       {
75715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75716       };
75717     } catch (...) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75720       };
75721     }
75722   }
75723   jresult = new Dali::Actor((const Dali::Actor &)result);
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75729   void * jresult ;
75730   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75731   Dali::Toolkit::TableView::CellPosition arg2 ;
75732   Dali::Toolkit::TableView::CellPosition *argp2 ;
75733   Dali::Actor result;
75734
75735   arg1 = (Dali::Toolkit::TableView *)jarg1;
75736   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75737   if (!argp2) {
75738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75739     return 0;
75740   }
75741   arg2 = *argp2;
75742   {
75743     try {
75744       result = (arg1)->RemoveChildAt(arg2);
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (...) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75756       };
75757     }
75758   }
75759   jresult = new Dali::Actor((const Dali::Actor &)result);
75760   return jresult;
75761 }
75762
75763
75764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75765   unsigned int jresult ;
75766   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75767   Dali::Actor arg2 ;
75768   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75769   Dali::Actor *argp2 ;
75770   bool result;
75771
75772   arg1 = (Dali::Toolkit::TableView *)jarg1;
75773   argp2 = (Dali::Actor *)jarg2;
75774   if (!argp2) {
75775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75776     return 0;
75777   }
75778   arg2 = *argp2;
75779   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75780   if (!arg3) {
75781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75782     return 0;
75783   }
75784   {
75785     try {
75786       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75787     } catch (std::out_of_range& e) {
75788       {
75789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (std::exception& e) {
75792       {
75793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (...) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75798       };
75799     }
75800   }
75801   jresult = result;
75802   return jresult;
75803 }
75804
75805
75806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75807   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75808   unsigned int arg2 ;
75809
75810   arg1 = (Dali::Toolkit::TableView *)jarg1;
75811   arg2 = (unsigned int)jarg2;
75812   {
75813     try {
75814       (arg1)->InsertRow(arg2);
75815     } catch (std::out_of_range& e) {
75816       {
75817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75818       };
75819     } catch (std::exception& e) {
75820       {
75821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75822       };
75823     } catch (...) {
75824       {
75825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75826       };
75827     }
75828   }
75829 }
75830
75831
75832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75833   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75834   unsigned int arg2 ;
75835
75836   arg1 = (Dali::Toolkit::TableView *)jarg1;
75837   arg2 = (unsigned int)jarg2;
75838   {
75839     try {
75840       (arg1)->DeleteRow(arg2);
75841     } catch (std::out_of_range& e) {
75842       {
75843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75844       };
75845     } catch (std::exception& e) {
75846       {
75847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75852       };
75853     }
75854   }
75855 }
75856
75857
75858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75859   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75860   unsigned int arg2 ;
75861   std::vector< Dali::Actor > *arg3 = 0 ;
75862
75863   arg1 = (Dali::Toolkit::TableView *)jarg1;
75864   arg2 = (unsigned int)jarg2;
75865   arg3 = (std::vector< Dali::Actor > *)jarg3;
75866   if (!arg3) {
75867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75868     return ;
75869   }
75870   {
75871     try {
75872       (arg1)->DeleteRow(arg2,*arg3);
75873     } catch (std::out_of_range& e) {
75874       {
75875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (std::exception& e) {
75878       {
75879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75880       };
75881     } catch (...) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75884       };
75885     }
75886   }
75887 }
75888
75889
75890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75891   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75892   unsigned int arg2 ;
75893
75894   arg1 = (Dali::Toolkit::TableView *)jarg1;
75895   arg2 = (unsigned int)jarg2;
75896   {
75897     try {
75898       (arg1)->InsertColumn(arg2);
75899     } catch (std::out_of_range& e) {
75900       {
75901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75902       };
75903     } catch (std::exception& e) {
75904       {
75905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75906       };
75907     } catch (...) {
75908       {
75909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75910       };
75911     }
75912   }
75913 }
75914
75915
75916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75917   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75918   unsigned int arg2 ;
75919
75920   arg1 = (Dali::Toolkit::TableView *)jarg1;
75921   arg2 = (unsigned int)jarg2;
75922   {
75923     try {
75924       (arg1)->DeleteColumn(arg2);
75925     } catch (std::out_of_range& e) {
75926       {
75927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75928       };
75929     } catch (std::exception& e) {
75930       {
75931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75932       };
75933     } catch (...) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75936       };
75937     }
75938   }
75939 }
75940
75941
75942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75943   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75944   unsigned int arg2 ;
75945   std::vector< Dali::Actor > *arg3 = 0 ;
75946
75947   arg1 = (Dali::Toolkit::TableView *)jarg1;
75948   arg2 = (unsigned int)jarg2;
75949   arg3 = (std::vector< Dali::Actor > *)jarg3;
75950   if (!arg3) {
75951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75952     return ;
75953   }
75954   {
75955     try {
75956       (arg1)->DeleteColumn(arg2,*arg3);
75957     } catch (std::out_of_range& e) {
75958       {
75959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75960       };
75961     } catch (std::exception& e) {
75962       {
75963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75964       };
75965     } catch (...) {
75966       {
75967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75968       };
75969     }
75970   }
75971 }
75972
75973
75974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75975   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75976   unsigned int arg2 ;
75977   unsigned int arg3 ;
75978
75979   arg1 = (Dali::Toolkit::TableView *)jarg1;
75980   arg2 = (unsigned int)jarg2;
75981   arg3 = (unsigned int)jarg3;
75982   {
75983     try {
75984       (arg1)->Resize(arg2,arg3);
75985     } catch (std::out_of_range& e) {
75986       {
75987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75988       };
75989     } catch (std::exception& e) {
75990       {
75991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75992       };
75993     } catch (...) {
75994       {
75995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75996       };
75997     }
75998   }
75999 }
76000
76001
76002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76003   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76004   unsigned int arg2 ;
76005   unsigned int arg3 ;
76006   std::vector< Dali::Actor > *arg4 = 0 ;
76007
76008   arg1 = (Dali::Toolkit::TableView *)jarg1;
76009   arg2 = (unsigned int)jarg2;
76010   arg3 = (unsigned int)jarg3;
76011   arg4 = (std::vector< Dali::Actor > *)jarg4;
76012   if (!arg4) {
76013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76014     return ;
76015   }
76016   {
76017     try {
76018       (arg1)->Resize(arg2,arg3,*arg4);
76019     } catch (std::out_of_range& e) {
76020       {
76021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76022       };
76023     } catch (std::exception& e) {
76024       {
76025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76026       };
76027     } catch (...) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76030       };
76031     }
76032   }
76033 }
76034
76035
76036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76037   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76038   Dali::Size arg2 ;
76039   Dali::Size *argp2 ;
76040
76041   arg1 = (Dali::Toolkit::TableView *)jarg1;
76042   argp2 = (Dali::Size *)jarg2;
76043   if (!argp2) {
76044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76045     return ;
76046   }
76047   arg2 = *argp2;
76048   {
76049     try {
76050       (arg1)->SetCellPadding(arg2);
76051     } catch (std::out_of_range& e) {
76052       {
76053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76054       };
76055     } catch (std::exception& e) {
76056       {
76057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76062       };
76063     }
76064   }
76065 }
76066
76067
76068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76069   void * jresult ;
76070   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76071   Dali::Size result;
76072
76073   arg1 = (Dali::Toolkit::TableView *)jarg1;
76074   {
76075     try {
76076       result = (arg1)->GetCellPadding();
76077     } catch (std::out_of_range& e) {
76078       {
76079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (std::exception& e) {
76082       {
76083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (...) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76088       };
76089     }
76090   }
76091   jresult = new Dali::Size((const Dali::Size &)result);
76092   return jresult;
76093 }
76094
76095
76096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76097   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76098   unsigned int arg2 ;
76099
76100   arg1 = (Dali::Toolkit::TableView *)jarg1;
76101   arg2 = (unsigned int)jarg2;
76102   {
76103     try {
76104       (arg1)->SetFitHeight(arg2);
76105     } catch (std::out_of_range& e) {
76106       {
76107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76108       };
76109     } catch (std::exception& e) {
76110       {
76111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76112       };
76113     } catch (...) {
76114       {
76115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76116       };
76117     }
76118   }
76119 }
76120
76121
76122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76123   unsigned int jresult ;
76124   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76125   unsigned int arg2 ;
76126   bool result;
76127
76128   arg1 = (Dali::Toolkit::TableView *)jarg1;
76129   arg2 = (unsigned int)jarg2;
76130   {
76131     try {
76132       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76133     } catch (std::out_of_range& e) {
76134       {
76135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76136       };
76137     } catch (std::exception& e) {
76138       {
76139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76140       };
76141     } catch (...) {
76142       {
76143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76144       };
76145     }
76146   }
76147   jresult = result;
76148   return jresult;
76149 }
76150
76151
76152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76154   unsigned int arg2 ;
76155
76156   arg1 = (Dali::Toolkit::TableView *)jarg1;
76157   arg2 = (unsigned int)jarg2;
76158   {
76159     try {
76160       (arg1)->SetFitWidth(arg2);
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175 }
76176
76177
76178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76179   unsigned int jresult ;
76180   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76181   unsigned int arg2 ;
76182   bool result;
76183
76184   arg1 = (Dali::Toolkit::TableView *)jarg1;
76185   arg2 = (unsigned int)jarg2;
76186   {
76187     try {
76188       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76189     } catch (std::out_of_range& e) {
76190       {
76191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76192       };
76193     } catch (std::exception& e) {
76194       {
76195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76196       };
76197     } catch (...) {
76198       {
76199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76200       };
76201     }
76202   }
76203   jresult = result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76210   unsigned int arg2 ;
76211   float arg3 ;
76212
76213   arg1 = (Dali::Toolkit::TableView *)jarg1;
76214   arg2 = (unsigned int)jarg2;
76215   arg3 = (float)jarg3;
76216   {
76217     try {
76218       (arg1)->SetFixedHeight(arg2,arg3);
76219     } catch (std::out_of_range& e) {
76220       {
76221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76222       };
76223     } catch (std::exception& e) {
76224       {
76225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76226       };
76227     } catch (...) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76230       };
76231     }
76232   }
76233 }
76234
76235
76236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76237   float jresult ;
76238   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76239   unsigned int arg2 ;
76240   float result;
76241
76242   arg1 = (Dali::Toolkit::TableView *)jarg1;
76243   arg2 = (unsigned int)jarg2;
76244   {
76245     try {
76246       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76247     } catch (std::out_of_range& e) {
76248       {
76249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76250       };
76251     } catch (std::exception& e) {
76252       {
76253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76254       };
76255     } catch (...) {
76256       {
76257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76258       };
76259     }
76260   }
76261   jresult = result;
76262   return jresult;
76263 }
76264
76265
76266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76267   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76268   unsigned int arg2 ;
76269   float arg3 ;
76270
76271   arg1 = (Dali::Toolkit::TableView *)jarg1;
76272   arg2 = (unsigned int)jarg2;
76273   arg3 = (float)jarg3;
76274   {
76275     try {
76276       (arg1)->SetRelativeHeight(arg2,arg3);
76277     } catch (std::out_of_range& e) {
76278       {
76279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76280       };
76281     } catch (std::exception& e) {
76282       {
76283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76284       };
76285     } catch (...) {
76286       {
76287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76288       };
76289     }
76290   }
76291 }
76292
76293
76294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76295   float jresult ;
76296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76297   unsigned int arg2 ;
76298   float result;
76299
76300   arg1 = (Dali::Toolkit::TableView *)jarg1;
76301   arg2 = (unsigned int)jarg2;
76302   {
76303     try {
76304       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76305     } catch (std::out_of_range& e) {
76306       {
76307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76308       };
76309     } catch (std::exception& e) {
76310       {
76311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76312       };
76313     } catch (...) {
76314       {
76315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76316       };
76317     }
76318   }
76319   jresult = result;
76320   return jresult;
76321 }
76322
76323
76324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76325   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76326   unsigned int arg2 ;
76327   float arg3 ;
76328
76329   arg1 = (Dali::Toolkit::TableView *)jarg1;
76330   arg2 = (unsigned int)jarg2;
76331   arg3 = (float)jarg3;
76332   {
76333     try {
76334       (arg1)->SetFixedWidth(arg2,arg3);
76335     } catch (std::out_of_range& e) {
76336       {
76337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76338       };
76339     } catch (std::exception& e) {
76340       {
76341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76342       };
76343     } catch (...) {
76344       {
76345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76346       };
76347     }
76348   }
76349 }
76350
76351
76352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76353   float jresult ;
76354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76355   unsigned int arg2 ;
76356   float result;
76357
76358   arg1 = (Dali::Toolkit::TableView *)jarg1;
76359   arg2 = (unsigned int)jarg2;
76360   {
76361     try {
76362       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76363     } catch (std::out_of_range& e) {
76364       {
76365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76366       };
76367     } catch (std::exception& e) {
76368       {
76369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76370       };
76371     } catch (...) {
76372       {
76373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76374       };
76375     }
76376   }
76377   jresult = result;
76378   return jresult;
76379 }
76380
76381
76382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76384   unsigned int arg2 ;
76385   float arg3 ;
76386
76387   arg1 = (Dali::Toolkit::TableView *)jarg1;
76388   arg2 = (unsigned int)jarg2;
76389   arg3 = (float)jarg3;
76390   {
76391     try {
76392       (arg1)->SetRelativeWidth(arg2,arg3);
76393     } catch (std::out_of_range& e) {
76394       {
76395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76396       };
76397     } catch (std::exception& e) {
76398       {
76399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76400       };
76401     } catch (...) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76404       };
76405     }
76406   }
76407 }
76408
76409
76410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76411   float jresult ;
76412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76413   unsigned int arg2 ;
76414   float result;
76415
76416   arg1 = (Dali::Toolkit::TableView *)jarg1;
76417   arg2 = (unsigned int)jarg2;
76418   {
76419     try {
76420       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76421     } catch (std::out_of_range& e) {
76422       {
76423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76424       };
76425     } catch (std::exception& e) {
76426       {
76427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76428       };
76429     } catch (...) {
76430       {
76431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76432       };
76433     }
76434   }
76435   jresult = result;
76436   return jresult;
76437 }
76438
76439
76440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76441   unsigned int jresult ;
76442   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76443   unsigned int result;
76444
76445   arg1 = (Dali::Toolkit::TableView *)jarg1;
76446   {
76447     try {
76448       result = (unsigned int)(arg1)->GetRows();
76449     } catch (std::out_of_range& e) {
76450       {
76451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76452       };
76453     } catch (std::exception& e) {
76454       {
76455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76456       };
76457     } catch (...) {
76458       {
76459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76460       };
76461     }
76462   }
76463   jresult = result;
76464   return jresult;
76465 }
76466
76467
76468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76469   unsigned int jresult ;
76470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76471   unsigned int result;
76472
76473   arg1 = (Dali::Toolkit::TableView *)jarg1;
76474   {
76475     try {
76476       result = (unsigned int)(arg1)->GetColumns();
76477     } catch (std::out_of_range& e) {
76478       {
76479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76480       };
76481     } catch (std::exception& e) {
76482       {
76483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76484       };
76485     } catch (...) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76488       };
76489     }
76490   }
76491   jresult = result;
76492   return jresult;
76493 }
76494
76495
76496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76498   Dali::Toolkit::TableView::CellPosition arg2 ;
76499   Dali::HorizontalAlignment::Type arg3 ;
76500   Dali::VerticalAlignment::Type arg4 ;
76501   Dali::Toolkit::TableView::CellPosition *argp2 ;
76502
76503   arg1 = (Dali::Toolkit::TableView *)jarg1;
76504   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76505   if (!argp2) {
76506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76507     return ;
76508   }
76509   arg2 = *argp2;
76510   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76511   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76512   {
76513     try {
76514       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76515     } catch (std::out_of_range& e) {
76516       {
76517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (std::exception& e) {
76520       {
76521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76526       };
76527     }
76528   }
76529 }
76530
76531
76532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76533   unsigned int jresult ;
76534   unsigned int result;
76535
76536   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76537   jresult = result;
76538   return jresult;
76539 }
76540
76541
76542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76543   int jresult ;
76544   int result;
76545
76546   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76547   jresult = (int)result;
76548   return jresult;
76549 }
76550
76551
76552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76553   int jresult ;
76554   int result;
76555
76556   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76557   jresult = (int)result;
76558   return jresult;
76559 }
76560
76561
76562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76563   int jresult ;
76564   int result;
76565
76566   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76567   jresult = (int)result;
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76573   int jresult ;
76574   int result;
76575
76576   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76577   jresult = (int)result;
76578   return jresult;
76579 }
76580
76581
76582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76583   int jresult ;
76584   int result;
76585
76586   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76587   jresult = (int)result;
76588   return jresult;
76589 }
76590
76591
76592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76593   int jresult ;
76594   int result;
76595
76596   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76597   jresult = (int)result;
76598   return jresult;
76599 }
76600
76601
76602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76603   int jresult ;
76604   int result;
76605
76606   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76607   jresult = (int)result;
76608   return jresult;
76609 }
76610
76611
76612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76613   int jresult ;
76614   int result;
76615
76616   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76617   jresult = (int)result;
76618   return jresult;
76619 }
76620
76621
76622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76623   int jresult ;
76624   int result;
76625
76626   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76627   jresult = (int)result;
76628   return jresult;
76629 }
76630
76631
76632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76633   int jresult ;
76634   int result;
76635
76636   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76637   jresult = (int)result;
76638   return jresult;
76639 }
76640
76641
76642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76643   int jresult ;
76644   int result;
76645
76646   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76647   jresult = (int)result;
76648   return jresult;
76649 }
76650
76651
76652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76653   int jresult ;
76654   int result;
76655
76656   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76657   jresult = (int)result;
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76663   int jresult ;
76664   int result;
76665
76666   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76667   jresult = (int)result;
76668   return jresult;
76669 }
76670
76671
76672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76673   int jresult ;
76674   int result;
76675
76676   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76677   jresult = (int)result;
76678   return jresult;
76679 }
76680
76681
76682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76683   int jresult ;
76684   int result;
76685
76686   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76687   jresult = (int)result;
76688   return jresult;
76689 }
76690
76691
76692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76693   int jresult ;
76694   int result;
76695
76696   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76697   jresult = (int)result;
76698   return jresult;
76699 }
76700
76701
76702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76703   int jresult ;
76704   int result;
76705
76706   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76707   jresult = (int)result;
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76713   int jresult ;
76714   int result;
76715
76716   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76717   jresult = (int)result;
76718   return jresult;
76719 }
76720
76721
76722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76723   int jresult ;
76724   int result;
76725
76726   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76727   jresult = (int)result;
76728   return jresult;
76729 }
76730
76731
76732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76733   int jresult ;
76734   int result;
76735
76736   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76737   jresult = (int)result;
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76743   int jresult ;
76744   int result;
76745
76746   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76747   jresult = (int)result;
76748   return jresult;
76749 }
76750
76751
76752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76753   int jresult ;
76754   int result;
76755
76756   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76757   jresult = (int)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76763   int jresult ;
76764   int result;
76765
76766   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76767   jresult = (int)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76773   int jresult ;
76774   int result;
76775
76776   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76777   jresult = (int)result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76783   int jresult ;
76784   int result;
76785
76786   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76787   jresult = (int)result;
76788   return jresult;
76789 }
76790
76791
76792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76793   int jresult ;
76794   int result;
76795
76796   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76797   jresult = (int)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76803   int jresult ;
76804   int result;
76805
76806   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76807   jresult = (int)result;
76808   return jresult;
76809 }
76810
76811
76812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76813   int jresult ;
76814   int result;
76815
76816   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76817   jresult = (int)result;
76818   return jresult;
76819 }
76820
76821
76822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76823   int jresult ;
76824   int result;
76825
76826   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76827   jresult = (int)result;
76828   return jresult;
76829 }
76830
76831
76832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76833   int jresult ;
76834   int result;
76835
76836   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76837   jresult = (int)result;
76838   return jresult;
76839 }
76840
76841
76842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76843   int jresult ;
76844   int result;
76845
76846   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76847   jresult = (int)result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76853   int jresult ;
76854   int result;
76855
76856   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76857   jresult = (int)result;
76858   return jresult;
76859 }
76860
76861
76862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76863   int jresult ;
76864   int result;
76865
76866   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76867   jresult = (int)result;
76868   return jresult;
76869 }
76870
76871
76872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76873   int jresult ;
76874   int result;
76875
76876   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76877   jresult = (int)result;
76878   return jresult;
76879 }
76880
76881
76882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76883   int jresult ;
76884   int result;
76885
76886   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76887   jresult = (int)result;
76888   return jresult;
76889 }
76890
76891
76892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76893   int jresult ;
76894   int result;
76895
76896   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76897   jresult = (int)result;
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76903   int jresult ;
76904   int result;
76905
76906   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76907   jresult = (int)result;
76908   return jresult;
76909 }
76910
76911
76912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76913   int jresult ;
76914   int result;
76915
76916   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76917   jresult = (int)result;
76918   return jresult;
76919 }
76920
76921
76922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76923   int jresult ;
76924   int result;
76925
76926   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76927   jresult = (int)result;
76928   return jresult;
76929 }
76930
76931
76932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76933   int jresult ;
76934   int result;
76935
76936   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76937   jresult = (int)result;
76938   return jresult;
76939 }
76940
76941
76942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76943   void * jresult ;
76944   Dali::Toolkit::TextEditor::Property *result = 0 ;
76945
76946   {
76947     try {
76948       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
76949     } catch (std::out_of_range& e) {
76950       {
76951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76952       };
76953     } catch (std::exception& e) {
76954       {
76955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76956       };
76957     } catch (...) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76960       };
76961     }
76962   }
76963   jresult = (void *)result;
76964   return jresult;
76965 }
76966
76967
76968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76969   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76970
76971   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76972   {
76973     try {
76974       delete arg1;
76975     } catch (std::out_of_range& e) {
76976       {
76977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76978       };
76979     } catch (std::exception& e) {
76980       {
76981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76982       };
76983     } catch (...) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76986       };
76987     }
76988   }
76989 }
76990
76991
76992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76993   void * jresult ;
76994   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76995
76996   {
76997     try {
76998       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76999     } catch (std::out_of_range& e) {
77000       {
77001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77002       };
77003     } catch (std::exception& e) {
77004       {
77005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77006       };
77007     } catch (...) {
77008       {
77009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77010       };
77011     }
77012   }
77013   jresult = (void *)result;
77014   return jresult;
77015 }
77016
77017
77018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77019   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77020
77021   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77022   {
77023     try {
77024       delete arg1;
77025     } catch (std::out_of_range& e) {
77026       {
77027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77028       };
77029     } catch (std::exception& e) {
77030       {
77031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77032       };
77033     } catch (...) {
77034       {
77035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77036       };
77037     }
77038   }
77039 }
77040
77041
77042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77043   void * jresult ;
77044   Dali::Toolkit::TextEditor result;
77045
77046   {
77047     try {
77048       result = Dali::Toolkit::TextEditor::New();
77049     } catch (std::out_of_range& e) {
77050       {
77051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77052       };
77053     } catch (std::exception& e) {
77054       {
77055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (...) {
77058       {
77059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77060       };
77061     }
77062   }
77063   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77064   return jresult;
77065 }
77066
77067
77068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77069   void * jresult ;
77070   Dali::Toolkit::TextEditor *result = 0 ;
77071
77072   {
77073     try {
77074       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77075     } catch (std::out_of_range& e) {
77076       {
77077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77078       };
77079     } catch (std::exception& e) {
77080       {
77081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (...) {
77084       {
77085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77086       };
77087     }
77088   }
77089   jresult = (void *)result;
77090   return jresult;
77091 }
77092
77093
77094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77095   void * jresult ;
77096   Dali::Toolkit::TextEditor *arg1 = 0 ;
77097   Dali::Toolkit::TextEditor *result = 0 ;
77098
77099   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77100   if (!arg1) {
77101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77102     return 0;
77103   }
77104   {
77105     try {
77106       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77107     } catch (std::out_of_range& e) {
77108       {
77109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77110       };
77111     } catch (std::exception& e) {
77112       {
77113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77114       };
77115     } catch (...) {
77116       {
77117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77118       };
77119     }
77120   }
77121   jresult = (void *)result;
77122   return jresult;
77123 }
77124
77125
77126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77127   void * jresult ;
77128   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77129   Dali::Toolkit::TextEditor *arg2 = 0 ;
77130   Dali::Toolkit::TextEditor *result = 0 ;
77131
77132   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77133   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77134   if (!arg2) {
77135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77136     return 0;
77137   }
77138   {
77139     try {
77140       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77141     } catch (std::out_of_range& e) {
77142       {
77143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77144       };
77145     } catch (std::exception& e) {
77146       {
77147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77148       };
77149     } catch (...) {
77150       {
77151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77152       };
77153     }
77154   }
77155   jresult = (void *)result;
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77161   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77162
77163   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77164   {
77165     try {
77166       delete arg1;
77167     } catch (std::out_of_range& e) {
77168       {
77169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77170       };
77171     } catch (std::exception& e) {
77172       {
77173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77174       };
77175     } catch (...) {
77176       {
77177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77178       };
77179     }
77180   }
77181 }
77182
77183
77184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77185   void * jresult ;
77186   Dali::BaseHandle arg1 ;
77187   Dali::BaseHandle *argp1 ;
77188   Dali::Toolkit::TextEditor result;
77189
77190   argp1 = (Dali::BaseHandle *)jarg1;
77191   if (!argp1) {
77192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77193     return 0;
77194   }
77195   arg1 = *argp1;
77196   {
77197     try {
77198       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77199     } catch (std::out_of_range& e) {
77200       {
77201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77202       };
77203     } catch (std::exception& e) {
77204       {
77205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77206       };
77207     } catch (...) {
77208       {
77209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77210       };
77211     }
77212   }
77213   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77214   return jresult;
77215 }
77216
77217
77218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77219   void * jresult ;
77220   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77221   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77222
77223   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77224   {
77225     try {
77226       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77227     } catch (std::out_of_range& e) {
77228       {
77229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77230       };
77231     } catch (std::exception& e) {
77232       {
77233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77234       };
77235     } catch (...) {
77236       {
77237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77238       };
77239     }
77240   }
77241   jresult = (void *)result;
77242   return jresult;
77243 }
77244
77245
77246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77247   void * jresult ;
77248   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77249   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77250
77251   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77252   {
77253     try {
77254       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77255     } catch (std::out_of_range& e) {
77256       {
77257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77258       };
77259     } catch (std::exception& e) {
77260       {
77261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77262       };
77263     } catch (...) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77266       };
77267     }
77268   }
77269   jresult = (void *)result;
77270   return jresult;
77271 }
77272
77273
77274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77275   int jresult ;
77276   int result;
77277
77278   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77279   jresult = (int)result;
77280   return jresult;
77281 }
77282
77283
77284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77285   int jresult ;
77286   int result;
77287
77288   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77289   jresult = (int)result;
77290   return jresult;
77291 }
77292
77293
77294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77295   int jresult ;
77296   int result;
77297
77298   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77299   jresult = (int)result;
77300   return jresult;
77301 }
77302
77303
77304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77305   int jresult ;
77306   int result;
77307
77308   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77309   jresult = (int)result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77315   int jresult ;
77316   int result;
77317
77318   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77319   jresult = (int)result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77325   int jresult ;
77326   int result;
77327
77328   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77329   jresult = (int)result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77335   int jresult ;
77336   int result;
77337
77338   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77339   jresult = (int)result;
77340   return jresult;
77341 }
77342
77343
77344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77345   int jresult ;
77346   int result;
77347
77348   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77349   jresult = (int)result;
77350   return jresult;
77351 }
77352
77353
77354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77355   int jresult ;
77356   int result;
77357
77358   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77359   jresult = (int)result;
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77365   int jresult ;
77366   int result;
77367
77368   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77369   jresult = (int)result;
77370   return jresult;
77371 }
77372
77373
77374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77375   int jresult ;
77376   int result;
77377
77378   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77379   jresult = (int)result;
77380   return jresult;
77381 }
77382
77383
77384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77385   int jresult ;
77386   int result;
77387
77388   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77389   jresult = (int)result;
77390   return jresult;
77391 }
77392
77393
77394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77395   int jresult ;
77396   int result;
77397
77398   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77399   jresult = (int)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77405   int jresult ;
77406   int result;
77407
77408   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77415   int jresult ;
77416   int result;
77417
77418   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77419   jresult = (int)result;
77420   return jresult;
77421 }
77422
77423
77424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77425   int jresult ;
77426   int result;
77427
77428   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77429   jresult = (int)result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77435   int jresult ;
77436   int result;
77437
77438   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77439   jresult = (int)result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77445   int jresult ;
77446   int result;
77447
77448   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77449   jresult = (int)result;
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77455   int jresult ;
77456   int result;
77457
77458   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77459   jresult = (int)result;
77460   return jresult;
77461 }
77462
77463
77464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77465   int jresult ;
77466   int result;
77467
77468   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77469   jresult = (int)result;
77470   return jresult;
77471 }
77472
77473
77474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77475   int jresult ;
77476   int result;
77477
77478   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77479   jresult = (int)result;
77480   return jresult;
77481 }
77482
77483
77484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77485   int jresult ;
77486   int result;
77487
77488   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77489   jresult = (int)result;
77490   return jresult;
77491 }
77492
77493
77494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77495   int jresult ;
77496   int result;
77497
77498   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77499   jresult = (int)result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77505   int jresult ;
77506   int result;
77507
77508   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77509   jresult = (int)result;
77510   return jresult;
77511 }
77512
77513
77514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77515   int jresult ;
77516   int result;
77517
77518   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77519   jresult = (int)result;
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77525   int jresult ;
77526   int result;
77527
77528   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77529   jresult = (int)result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77535   int jresult ;
77536   int result;
77537
77538   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77539   jresult = (int)result;
77540   return jresult;
77541 }
77542
77543
77544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77545   int jresult ;
77546   int result;
77547
77548   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77549   jresult = (int)result;
77550   return jresult;
77551 }
77552
77553
77554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77555   int jresult ;
77556   int result;
77557
77558   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77559   jresult = (int)result;
77560   return jresult;
77561 }
77562
77563
77564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77565   int jresult ;
77566   int result;
77567
77568   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77569   jresult = (int)result;
77570   return jresult;
77571 }
77572
77573
77574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77575   int jresult ;
77576   int result;
77577
77578   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77579   jresult = (int)result;
77580   return jresult;
77581 }
77582
77583
77584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77585   int jresult ;
77586   int result;
77587
77588   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77589   jresult = (int)result;
77590   return jresult;
77591 }
77592
77593
77594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77595   int jresult ;
77596   int result;
77597
77598   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77599   jresult = (int)result;
77600   return jresult;
77601 }
77602
77603
77604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77605   int jresult ;
77606   int result;
77607
77608   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77609   jresult = (int)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77615   int jresult ;
77616   int result;
77617
77618   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77619   jresult = (int)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77625   int jresult ;
77626   int result;
77627
77628   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77629   jresult = (int)result;
77630   return jresult;
77631 }
77632
77633
77634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77635   int jresult ;
77636   int result;
77637
77638   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77639   jresult = (int)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77645   int jresult ;
77646   int result;
77647
77648   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77649   jresult = (int)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77655   int jresult ;
77656   int result;
77657
77658   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77659   jresult = (int)result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77665   int jresult ;
77666   int result;
77667
77668   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77669   jresult = (int)result;
77670   return jresult;
77671 }
77672
77673
77674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77675   int jresult ;
77676   int result;
77677
77678   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77685   int jresult ;
77686   int result;
77687
77688   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77689   jresult = (int)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77735   int jresult ;
77736   int result;
77737
77738   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77739   jresult = (int)result;
77740   return jresult;
77741 }
77742
77743
77744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77745   void * jresult ;
77746   Dali::Toolkit::TextField::Property *result = 0 ;
77747
77748   {
77749     try {
77750       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77751     } catch (std::out_of_range& e) {
77752       {
77753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77754       };
77755     } catch (std::exception& e) {
77756       {
77757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77758       };
77759     } catch (...) {
77760       {
77761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77762       };
77763     }
77764   }
77765   jresult = (void *)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77771   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77772
77773   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77774   {
77775     try {
77776       delete arg1;
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77784       };
77785     } catch (...) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77788       };
77789     }
77790   }
77791 }
77792
77793
77794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77795   void * jresult ;
77796   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77797
77798   {
77799     try {
77800       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77801     } catch (std::out_of_range& e) {
77802       {
77803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77804       };
77805     } catch (std::exception& e) {
77806       {
77807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77808       };
77809     } catch (...) {
77810       {
77811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77812       };
77813     }
77814   }
77815   jresult = (void *)result;
77816   return jresult;
77817 }
77818
77819
77820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77821   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77822
77823   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77824   {
77825     try {
77826       delete arg1;
77827     } catch (std::out_of_range& e) {
77828       {
77829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77830       };
77831     } catch (std::exception& e) {
77832       {
77833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77834       };
77835     } catch (...) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77838       };
77839     }
77840   }
77841 }
77842
77843
77844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77845   void * jresult ;
77846   Dali::Toolkit::TextField result;
77847
77848   {
77849     try {
77850       result = Dali::Toolkit::TextField::New();
77851     } catch (std::out_of_range& e) {
77852       {
77853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77854       };
77855     } catch (std::exception& e) {
77856       {
77857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77858       };
77859     } catch (...) {
77860       {
77861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77862       };
77863     }
77864   }
77865   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77866   return jresult;
77867 }
77868
77869
77870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77871   void * jresult ;
77872   Dali::Toolkit::TextField *result = 0 ;
77873
77874   {
77875     try {
77876       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77877     } catch (std::out_of_range& e) {
77878       {
77879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77880       };
77881     } catch (std::exception& e) {
77882       {
77883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77884       };
77885     } catch (...) {
77886       {
77887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77888       };
77889     }
77890   }
77891   jresult = (void *)result;
77892   return jresult;
77893 }
77894
77895
77896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77897   void * jresult ;
77898   Dali::Toolkit::TextField *arg1 = 0 ;
77899   Dali::Toolkit::TextField *result = 0 ;
77900
77901   arg1 = (Dali::Toolkit::TextField *)jarg1;
77902   if (!arg1) {
77903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77904     return 0;
77905   }
77906   {
77907     try {
77908       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77909     } catch (std::out_of_range& e) {
77910       {
77911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77912       };
77913     } catch (std::exception& e) {
77914       {
77915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (...) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77920       };
77921     }
77922   }
77923   jresult = (void *)result;
77924   return jresult;
77925 }
77926
77927
77928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77929   void * jresult ;
77930   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77931   Dali::Toolkit::TextField *arg2 = 0 ;
77932   Dali::Toolkit::TextField *result = 0 ;
77933
77934   arg1 = (Dali::Toolkit::TextField *)jarg1;
77935   arg2 = (Dali::Toolkit::TextField *)jarg2;
77936   if (!arg2) {
77937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77938     return 0;
77939   }
77940   {
77941     try {
77942       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77943     } catch (std::out_of_range& e) {
77944       {
77945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77946       };
77947     } catch (std::exception& e) {
77948       {
77949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77950       };
77951     } catch (...) {
77952       {
77953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77954       };
77955     }
77956   }
77957   jresult = (void *)result;
77958   return jresult;
77959 }
77960
77961
77962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77963   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77964
77965   arg1 = (Dali::Toolkit::TextField *)jarg1;
77966   {
77967     try {
77968       delete arg1;
77969     } catch (std::out_of_range& e) {
77970       {
77971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77972       };
77973     } catch (std::exception& e) {
77974       {
77975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77976       };
77977     } catch (...) {
77978       {
77979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77980       };
77981     }
77982   }
77983 }
77984
77985
77986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77987   void * jresult ;
77988   Dali::BaseHandle arg1 ;
77989   Dali::BaseHandle *argp1 ;
77990   Dali::Toolkit::TextField result;
77991
77992   argp1 = (Dali::BaseHandle *)jarg1;
77993   if (!argp1) {
77994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77995     return 0;
77996   }
77997   arg1 = *argp1;
77998   {
77999     try {
78000       result = Dali::Toolkit::TextField::DownCast(arg1);
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (...) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78012       };
78013     }
78014   }
78015   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78016   return jresult;
78017 }
78018
78019
78020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78021   void * jresult ;
78022   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78023   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78024
78025   arg1 = (Dali::Toolkit::TextField *)jarg1;
78026   {
78027     try {
78028       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78029     } catch (std::out_of_range& e) {
78030       {
78031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (std::exception& e) {
78034       {
78035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (...) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78040       };
78041     }
78042   }
78043   jresult = (void *)result;
78044   return jresult;
78045 }
78046
78047
78048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78049   void * jresult ;
78050   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78051   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78052
78053   arg1 = (Dali::Toolkit::TextField *)jarg1;
78054   {
78055     try {
78056       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78057     } catch (std::out_of_range& e) {
78058       {
78059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (std::exception& e) {
78062       {
78063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78064       };
78065     } catch (...) {
78066       {
78067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78068       };
78069     }
78070   }
78071   jresult = (void *)result;
78072   return jresult;
78073 }
78074
78075
78076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78077   void * jresult ;
78078   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78079   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78080
78081   arg1 = (Dali::Toolkit::TextField *)jarg1;
78082   {
78083     try {
78084       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78085     } catch (std::out_of_range& e) {
78086       {
78087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78088       };
78089     } catch (std::exception& e) {
78090       {
78091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78092       };
78093     } catch (...) {
78094       {
78095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78096       };
78097     }
78098   }
78099   jresult = (void *)result;
78100   return jresult;
78101 }
78102
78103
78104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78105   int jresult ;
78106   int result;
78107
78108   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78109   jresult = (int)result;
78110   return jresult;
78111 }
78112
78113
78114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78115   int jresult ;
78116   int result;
78117
78118   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78119   jresult = (int)result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78125   int jresult ;
78126   int result;
78127
78128   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78129   jresult = (int)result;
78130   return jresult;
78131 }
78132
78133
78134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78135   int jresult ;
78136   int result;
78137
78138   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78139   jresult = (int)result;
78140   return jresult;
78141 }
78142
78143
78144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78145   int jresult ;
78146   int result;
78147
78148   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78149   jresult = (int)result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78155   int jresult ;
78156   int result;
78157
78158   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78159   jresult = (int)result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78165   int jresult ;
78166   int result;
78167
78168   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78169   jresult = (int)result;
78170   return jresult;
78171 }
78172
78173
78174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78175   int jresult ;
78176   int result;
78177
78178   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78179   jresult = (int)result;
78180   return jresult;
78181 }
78182
78183
78184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78185   int jresult ;
78186   int result;
78187
78188   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78189   jresult = (int)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78195   int jresult ;
78196   int result;
78197
78198   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78199   jresult = (int)result;
78200   return jresult;
78201 }
78202
78203
78204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78205   int jresult ;
78206   int result;
78207
78208   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78209   jresult = (int)result;
78210   return jresult;
78211 }
78212
78213
78214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78215   int jresult ;
78216   int result;
78217
78218   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78219   jresult = (int)result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78225   int jresult ;
78226   int result;
78227
78228   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78229   jresult = (int)result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78235   int jresult ;
78236   int result;
78237
78238   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78239   jresult = (int)result;
78240   return jresult;
78241 }
78242
78243
78244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78245   int jresult ;
78246   int result;
78247
78248   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78249   jresult = (int)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78255   int jresult ;
78256   int result;
78257
78258   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78259   jresult = (int)result;
78260   return jresult;
78261 }
78262
78263
78264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78265   int jresult ;
78266   int result;
78267
78268   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78269   jresult = (int)result;
78270   return jresult;
78271 }
78272
78273
78274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78275   int jresult ;
78276   int result;
78277
78278   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78279   jresult = (int)result;
78280   return jresult;
78281 }
78282
78283
78284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78285   int jresult ;
78286   int result;
78287
78288   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78289   jresult = (int)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78295   int jresult ;
78296   int result;
78297
78298   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78299   jresult = (int)result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78305   int jresult ;
78306   int result;
78307
78308   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78309   jresult = (int)result;
78310   return jresult;
78311 }
78312
78313
78314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78315   int jresult ;
78316   int result;
78317
78318   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78319   jresult = (int)result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78325   int jresult ;
78326   int result;
78327
78328   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78329   jresult = (int)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78335   int jresult ;
78336   int result;
78337
78338   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78339   jresult = (int)result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78345   void * jresult ;
78346   Dali::Toolkit::TextLabel::Property *result = 0 ;
78347
78348   {
78349     try {
78350       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78351     } catch (std::out_of_range& e) {
78352       {
78353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78354       };
78355     } catch (std::exception& e) {
78356       {
78357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78358       };
78359     } catch (...) {
78360       {
78361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78362       };
78363     }
78364   }
78365   jresult = (void *)result;
78366   return jresult;
78367 }
78368
78369
78370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78371   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78372
78373   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78374   {
78375     try {
78376       delete arg1;
78377     } catch (std::out_of_range& e) {
78378       {
78379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78380       };
78381     } catch (std::exception& e) {
78382       {
78383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78384       };
78385     } catch (...) {
78386       {
78387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78388       };
78389     }
78390   }
78391 }
78392
78393
78394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78395   void * jresult ;
78396   Dali::Toolkit::TextLabel result;
78397
78398   {
78399     try {
78400       result = Dali::Toolkit::TextLabel::New();
78401     } catch (std::out_of_range& e) {
78402       {
78403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78404       };
78405     } catch (std::exception& e) {
78406       {
78407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78408       };
78409     } catch (...) {
78410       {
78411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78412       };
78413     }
78414   }
78415   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78416   return jresult;
78417 }
78418
78419
78420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78421   void * jresult ;
78422   std::string *arg1 = 0 ;
78423   Dali::Toolkit::TextLabel result;
78424
78425   if (!jarg1) {
78426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78427     return 0;
78428   }
78429   std::string arg1_str(jarg1);
78430   arg1 = &arg1_str;
78431   {
78432     try {
78433       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78434     } catch (std::out_of_range& e) {
78435       {
78436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78437       };
78438     } catch (std::exception& e) {
78439       {
78440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78441       };
78442     } catch (...) {
78443       {
78444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78445       };
78446     }
78447   }
78448   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78449
78450   //argout typemap for const std::string&
78451
78452   return jresult;
78453 }
78454
78455
78456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78457   void * jresult ;
78458   Dali::Toolkit::TextLabel *result = 0 ;
78459
78460   {
78461     try {
78462       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78463     } catch (std::out_of_range& e) {
78464       {
78465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78466       };
78467     } catch (std::exception& e) {
78468       {
78469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78470       };
78471     } catch (...) {
78472       {
78473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78474       };
78475     }
78476   }
78477   jresult = (void *)result;
78478   return jresult;
78479 }
78480
78481
78482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78483   void * jresult ;
78484   Dali::Toolkit::TextLabel *arg1 = 0 ;
78485   Dali::Toolkit::TextLabel *result = 0 ;
78486
78487   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78488   if (!arg1) {
78489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78490     return 0;
78491   }
78492   {
78493     try {
78494       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78495     } catch (std::out_of_range& e) {
78496       {
78497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78498       };
78499     } catch (std::exception& e) {
78500       {
78501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78502       };
78503     } catch (...) {
78504       {
78505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78506       };
78507     }
78508   }
78509   jresult = (void *)result;
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78515   void * jresult ;
78516   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78517   Dali::Toolkit::TextLabel *arg2 = 0 ;
78518   Dali::Toolkit::TextLabel *result = 0 ;
78519
78520   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78521   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78522   if (!arg2) {
78523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78524     return 0;
78525   }
78526   {
78527     try {
78528       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78529     } catch (std::out_of_range& e) {
78530       {
78531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78532       };
78533     } catch (std::exception& e) {
78534       {
78535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78536       };
78537     } catch (...) {
78538       {
78539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78540       };
78541     }
78542   }
78543   jresult = (void *)result;
78544   return jresult;
78545 }
78546
78547
78548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78549   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78550
78551   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78552   {
78553     try {
78554       delete arg1;
78555     } catch (std::out_of_range& e) {
78556       {
78557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78558       };
78559     } catch (std::exception& e) {
78560       {
78561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78562       };
78563     } catch (...) {
78564       {
78565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78566       };
78567     }
78568   }
78569 }
78570
78571
78572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78573   void * jresult ;
78574   Dali::BaseHandle arg1 ;
78575   Dali::BaseHandle *argp1 ;
78576   Dali::Toolkit::TextLabel result;
78577
78578   argp1 = (Dali::BaseHandle *)jarg1;
78579   if (!argp1) {
78580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78581     return 0;
78582   }
78583   arg1 = *argp1;
78584   {
78585     try {
78586       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78587     } catch (std::out_of_range& e) {
78588       {
78589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78590       };
78591     } catch (std::exception& e) {
78592       {
78593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78594       };
78595     } catch (...) {
78596       {
78597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78598       };
78599     }
78600   }
78601   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78602   return jresult;
78603 }
78604
78605
78606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78607   void * jresult ;
78608   Dali::Toolkit::AccessibilityManager *result = 0 ;
78609
78610   {
78611     try {
78612       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78613     } catch (std::out_of_range& e) {
78614       {
78615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (std::exception& e) {
78618       {
78619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627   jresult = (void *)result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78633   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78634
78635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78636   {
78637     try {
78638       delete arg1;
78639     } catch (std::out_of_range& e) {
78640       {
78641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78642       };
78643     } catch (std::exception& e) {
78644       {
78645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78646       };
78647     } catch (...) {
78648       {
78649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78650       };
78651     }
78652   }
78653 }
78654
78655
78656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78657   void * jresult ;
78658   Dali::Toolkit::AccessibilityManager result;
78659
78660   {
78661     try {
78662       result = Dali::Toolkit::AccessibilityManager::Get();
78663     } catch (std::out_of_range& e) {
78664       {
78665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78666       };
78667     } catch (std::exception& e) {
78668       {
78669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78670       };
78671     } catch (...) {
78672       {
78673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78674       };
78675     }
78676   }
78677   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78684   Dali::Actor arg2 ;
78685   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78686   std::string *arg4 = 0 ;
78687   Dali::Actor *argp2 ;
78688
78689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78690   argp2 = (Dali::Actor *)jarg2;
78691   if (!argp2) {
78692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78693     return ;
78694   }
78695   arg2 = *argp2;
78696   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78697   if (!jarg4) {
78698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78699     return ;
78700   }
78701   std::string arg4_str(jarg4);
78702   arg4 = &arg4_str;
78703   {
78704     try {
78705       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78706     } catch (std::out_of_range& e) {
78707       {
78708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78709       };
78710     } catch (std::exception& e) {
78711       {
78712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78713       };
78714     } catch (...) {
78715       {
78716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78717       };
78718     }
78719   }
78720
78721   //argout typemap for const std::string&
78722
78723 }
78724
78725
78726 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78727   char * jresult ;
78728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78729   Dali::Actor arg2 ;
78730   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78731   Dali::Actor *argp2 ;
78732   std::string result;
78733
78734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78735   argp2 = (Dali::Actor *)jarg2;
78736   if (!argp2) {
78737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78738     return 0;
78739   }
78740   arg2 = *argp2;
78741   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78742   {
78743     try {
78744       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (...) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78756       };
78757     }
78758   }
78759   jresult = SWIG_csharp_string_callback((&result)->c_str());
78760   return jresult;
78761 }
78762
78763
78764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78766   Dali::Actor arg2 ;
78767   unsigned int arg3 ;
78768   Dali::Actor *argp2 ;
78769
78770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78771   argp2 = (Dali::Actor *)jarg2;
78772   if (!argp2) {
78773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78774     return ;
78775   }
78776   arg2 = *argp2;
78777   arg3 = (unsigned int)jarg3;
78778   {
78779     try {
78780       (arg1)->SetFocusOrder(arg2,arg3);
78781     } catch (std::out_of_range& e) {
78782       {
78783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78784       };
78785     } catch (std::exception& e) {
78786       {
78787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78788       };
78789     } catch (...) {
78790       {
78791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78792       };
78793     }
78794   }
78795 }
78796
78797
78798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78799   unsigned int jresult ;
78800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78801   Dali::Actor arg2 ;
78802   Dali::Actor *argp2 ;
78803   unsigned int result;
78804
78805   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78806   argp2 = (Dali::Actor *)jarg2;
78807   if (!argp2) {
78808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78809     return 0;
78810   }
78811   arg2 = *argp2;
78812   {
78813     try {
78814       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78815     } catch (std::out_of_range& e) {
78816       {
78817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78818       };
78819     } catch (std::exception& e) {
78820       {
78821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78822       };
78823     } catch (...) {
78824       {
78825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78826       };
78827     }
78828   }
78829   jresult = result;
78830   return jresult;
78831 }
78832
78833
78834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78835   unsigned int jresult ;
78836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78837   unsigned int result;
78838
78839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78840   {
78841     try {
78842       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78843     } catch (std::out_of_range& e) {
78844       {
78845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78846       };
78847     } catch (std::exception& e) {
78848       {
78849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78850       };
78851     } catch (...) {
78852       {
78853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78854       };
78855     }
78856   }
78857   jresult = result;
78858   return jresult;
78859 }
78860
78861
78862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78863   void * jresult ;
78864   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78865   unsigned int arg2 ;
78866   Dali::Actor result;
78867
78868   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78869   arg2 = (unsigned int)jarg2;
78870   {
78871     try {
78872       result = (arg1)->GetActorByFocusOrder(arg2);
78873     } catch (std::out_of_range& e) {
78874       {
78875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (std::exception& e) {
78878       {
78879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78880       };
78881     } catch (...) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78884       };
78885     }
78886   }
78887   jresult = new Dali::Actor((const Dali::Actor &)result);
78888   return jresult;
78889 }
78890
78891
78892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78893   unsigned int jresult ;
78894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78895   Dali::Actor arg2 ;
78896   Dali::Actor *argp2 ;
78897   bool result;
78898
78899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78900   argp2 = (Dali::Actor *)jarg2;
78901   if (!argp2) {
78902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78903     return 0;
78904   }
78905   arg2 = *argp2;
78906   {
78907     try {
78908       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78909     } catch (std::out_of_range& e) {
78910       {
78911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78912       };
78913     } catch (std::exception& e) {
78914       {
78915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78916       };
78917     } catch (...) {
78918       {
78919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78920       };
78921     }
78922   }
78923   jresult = result;
78924   return jresult;
78925 }
78926
78927
78928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78929   void * jresult ;
78930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78931   Dali::Actor result;
78932
78933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78934   {
78935     try {
78936       result = (arg1)->GetCurrentFocusActor();
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (...) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78948       };
78949     }
78950   }
78951   jresult = new Dali::Actor((const Dali::Actor &)result);
78952   return jresult;
78953 }
78954
78955
78956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78957   void * jresult ;
78958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78959   Dali::Actor result;
78960
78961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78962   {
78963     try {
78964       result = (arg1)->GetCurrentFocusGroup();
78965     } catch (std::out_of_range& e) {
78966       {
78967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (std::exception& e) {
78970       {
78971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78972       };
78973     } catch (...) {
78974       {
78975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78976       };
78977     }
78978   }
78979   jresult = new Dali::Actor((const Dali::Actor &)result);
78980   return jresult;
78981 }
78982
78983
78984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78985   unsigned int jresult ;
78986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78987   unsigned int result;
78988
78989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78990   {
78991     try {
78992       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78993     } catch (std::out_of_range& e) {
78994       {
78995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78996       };
78997     } catch (std::exception& e) {
78998       {
78999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79000       };
79001     } catch (...) {
79002       {
79003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79004       };
79005     }
79006   }
79007   jresult = result;
79008   return jresult;
79009 }
79010
79011
79012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79013   unsigned int jresult ;
79014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79015   bool result;
79016
79017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79018   {
79019     try {
79020       result = (bool)(arg1)->MoveFocusForward();
79021     } catch (std::out_of_range& e) {
79022       {
79023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79024       };
79025     } catch (std::exception& e) {
79026       {
79027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79028       };
79029     } catch (...) {
79030       {
79031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79032       };
79033     }
79034   }
79035   jresult = result;
79036   return jresult;
79037 }
79038
79039
79040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79041   unsigned int jresult ;
79042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79043   bool result;
79044
79045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79046   {
79047     try {
79048       result = (bool)(arg1)->MoveFocusBackward();
79049     } catch (std::out_of_range& e) {
79050       {
79051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79052       };
79053     } catch (std::exception& e) {
79054       {
79055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79056       };
79057     } catch (...) {
79058       {
79059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79060       };
79061     }
79062   }
79063   jresult = result;
79064   return jresult;
79065 }
79066
79067
79068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79070
79071   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79072   {
79073     try {
79074       (arg1)->ClearFocus();
79075     } catch (std::out_of_range& e) {
79076       {
79077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79078       };
79079     } catch (std::exception& e) {
79080       {
79081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79082       };
79083     } catch (...) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79086       };
79087     }
79088   }
79089 }
79090
79091
79092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79094
79095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79096   {
79097     try {
79098       (arg1)->Reset();
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79106       };
79107     } catch (...) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79110       };
79111     }
79112   }
79113 }
79114
79115
79116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79117   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79118   Dali::Actor arg2 ;
79119   bool arg3 ;
79120   Dali::Actor *argp2 ;
79121
79122   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79123   argp2 = (Dali::Actor *)jarg2;
79124   if (!argp2) {
79125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79126     return ;
79127   }
79128   arg2 = *argp2;
79129   arg3 = jarg3 ? true : false;
79130   {
79131     try {
79132       (arg1)->SetFocusGroup(arg2,arg3);
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79144       };
79145     }
79146   }
79147 }
79148
79149
79150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79151   unsigned int jresult ;
79152   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79153   Dali::Actor arg2 ;
79154   Dali::Actor *argp2 ;
79155   bool result;
79156
79157   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79158   argp2 = (Dali::Actor *)jarg2;
79159   if (!argp2) {
79160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79161     return 0;
79162   }
79163   arg2 = *argp2;
79164   {
79165     try {
79166       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79167     } catch (std::out_of_range& e) {
79168       {
79169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79170       };
79171     } catch (std::exception& e) {
79172       {
79173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79174       };
79175     } catch (...) {
79176       {
79177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79178       };
79179     }
79180   }
79181   jresult = result;
79182   return jresult;
79183 }
79184
79185
79186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79187   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79188   bool arg2 ;
79189
79190   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79191   arg2 = jarg2 ? true : false;
79192   {
79193     try {
79194       (arg1)->SetGroupMode(arg2);
79195     } catch (std::out_of_range& e) {
79196       {
79197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79198       };
79199     } catch (std::exception& e) {
79200       {
79201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79202       };
79203     } catch (...) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79206       };
79207     }
79208   }
79209 }
79210
79211
79212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79213   unsigned int jresult ;
79214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79215   bool result;
79216
79217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79218   {
79219     try {
79220       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79221     } catch (std::out_of_range& e) {
79222       {
79223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79224       };
79225     } catch (std::exception& e) {
79226       {
79227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (...) {
79230       {
79231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79232       };
79233     }
79234   }
79235   jresult = result;
79236   return jresult;
79237 }
79238
79239
79240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79242   bool arg2 ;
79243
79244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79245   arg2 = jarg2 ? true : false;
79246   {
79247     try {
79248       (arg1)->SetWrapMode(arg2);
79249     } catch (std::out_of_range& e) {
79250       {
79251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79252       };
79253     } catch (std::exception& e) {
79254       {
79255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79256       };
79257     } catch (...) {
79258       {
79259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79260       };
79261     }
79262   }
79263 }
79264
79265
79266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79267   unsigned int jresult ;
79268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79269   bool result;
79270
79271   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79272   {
79273     try {
79274       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79275     } catch (std::out_of_range& e) {
79276       {
79277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (std::exception& e) {
79280       {
79281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289   jresult = result;
79290   return jresult;
79291 }
79292
79293
79294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79295   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79296   Dali::Actor arg2 ;
79297   Dali::Actor *argp2 ;
79298
79299   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79300   argp2 = (Dali::Actor *)jarg2;
79301   if (!argp2) {
79302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79303     return ;
79304   }
79305   arg2 = *argp2;
79306   {
79307     try {
79308       (arg1)->SetFocusIndicatorActor(arg2);
79309     } catch (std::out_of_range& e) {
79310       {
79311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79312       };
79313     } catch (std::exception& e) {
79314       {
79315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79316       };
79317     } catch (...) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79320       };
79321     }
79322   }
79323 }
79324
79325
79326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79327   void * jresult ;
79328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79329   Dali::Actor result;
79330
79331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79332   {
79333     try {
79334       result = (arg1)->GetFocusIndicatorActor();
79335     } catch (std::out_of_range& e) {
79336       {
79337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (std::exception& e) {
79340       {
79341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349   jresult = new Dali::Actor((const Dali::Actor &)result);
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79355   void * jresult ;
79356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79357   Dali::Actor arg2 ;
79358   Dali::Actor *argp2 ;
79359   Dali::Actor result;
79360
79361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79362   argp2 = (Dali::Actor *)jarg2;
79363   if (!argp2) {
79364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79365     return 0;
79366   }
79367   arg2 = *argp2;
79368   {
79369     try {
79370       result = (arg1)->GetFocusGroup(arg2);
79371     } catch (std::out_of_range& e) {
79372       {
79373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79374       };
79375     } catch (std::exception& e) {
79376       {
79377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79378       };
79379     } catch (...) {
79380       {
79381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79382       };
79383     }
79384   }
79385   jresult = new Dali::Actor((const Dali::Actor &)result);
79386   return jresult;
79387 }
79388
79389
79390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79391   void * jresult ;
79392   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79393   Dali::Vector2 result;
79394
79395   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79396   {
79397     try {
79398       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79399     } catch (std::out_of_range& e) {
79400       {
79401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (std::exception& e) {
79404       {
79405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79406       };
79407     } catch (...) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79410       };
79411     }
79412   }
79413   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79414   return jresult;
79415 }
79416
79417
79418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79419   void * jresult ;
79420   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79421   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79422
79423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79424   {
79425     try {
79426       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79427     } catch (std::out_of_range& e) {
79428       {
79429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79430       };
79431     } catch (std::exception& e) {
79432       {
79433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79434       };
79435     } catch (...) {
79436       {
79437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79438       };
79439     }
79440   }
79441   jresult = (void *)result;
79442   return jresult;
79443 }
79444
79445
79446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79447   void * jresult ;
79448   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79449   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79450
79451   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79452   {
79453     try {
79454       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79455     } catch (std::out_of_range& e) {
79456       {
79457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79458       };
79459     } catch (std::exception& e) {
79460       {
79461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79462       };
79463     } catch (...) {
79464       {
79465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79466       };
79467     }
79468   }
79469   jresult = (void *)result;
79470   return jresult;
79471 }
79472
79473
79474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79475   void * jresult ;
79476   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79477   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79478
79479   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79480   {
79481     try {
79482       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79483     } catch (std::out_of_range& e) {
79484       {
79485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79486       };
79487     } catch (std::exception& e) {
79488       {
79489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79490       };
79491     } catch (...) {
79492       {
79493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79494       };
79495     }
79496   }
79497   jresult = (void *)result;
79498   return jresult;
79499 }
79500
79501
79502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79503   void * jresult ;
79504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79505   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79506
79507   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79508   {
79509     try {
79510       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79511     } catch (std::out_of_range& e) {
79512       {
79513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79514       };
79515     } catch (std::exception& e) {
79516       {
79517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79518       };
79519     } catch (...) {
79520       {
79521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79522       };
79523     }
79524   }
79525   jresult = (void *)result;
79526   return jresult;
79527 }
79528
79529
79530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79531   void * jresult ;
79532   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79533   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79534
79535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79536   {
79537     try {
79538       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79539     } catch (std::out_of_range& e) {
79540       {
79541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (std::exception& e) {
79544       {
79545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79546       };
79547     } catch (...) {
79548       {
79549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79550       };
79551     }
79552   }
79553   jresult = (void *)result;
79554   return jresult;
79555 }
79556
79557
79558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79559   void * jresult ;
79560   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79561   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79562
79563   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79564   {
79565     try {
79566       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79567     } catch (std::out_of_range& e) {
79568       {
79569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79570       };
79571     } catch (std::exception& e) {
79572       {
79573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (...) {
79576       {
79577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79578       };
79579     }
79580   }
79581   jresult = (void *)result;
79582   return jresult;
79583 }
79584
79585
79586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79587   void * jresult ;
79588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79589   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79590
79591   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79592   {
79593     try {
79594       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79595     } catch (std::out_of_range& e) {
79596       {
79597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (std::exception& e) {
79600       {
79601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79602       };
79603     } catch (...) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79606       };
79607     }
79608   }
79609   jresult = (void *)result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79615   void * jresult ;
79616   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79617   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79618
79619   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79620   {
79621     try {
79622       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79623     } catch (std::out_of_range& e) {
79624       {
79625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79626       };
79627     } catch (std::exception& e) {
79628       {
79629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79630       };
79631     } catch (...) {
79632       {
79633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79634       };
79635     }
79636   }
79637   jresult = (void *)result;
79638   return jresult;
79639 }
79640
79641
79642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79643   void * jresult ;
79644   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79645   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79646
79647   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79648   {
79649     try {
79650       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79651     } catch (std::out_of_range& e) {
79652       {
79653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79654       };
79655     } catch (std::exception& e) {
79656       {
79657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79658       };
79659     } catch (...) {
79660       {
79661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79662       };
79663     }
79664   }
79665   jresult = (void *)result;
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79671   void * jresult ;
79672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79673   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79674
79675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79676   {
79677     try {
79678       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79679     } catch (std::out_of_range& e) {
79680       {
79681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79682       };
79683     } catch (std::exception& e) {
79684       {
79685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79686       };
79687     } catch (...) {
79688       {
79689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79690       };
79691     }
79692   }
79693   jresult = (void *)result;
79694   return jresult;
79695 }
79696
79697
79698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79699   void * jresult ;
79700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79701   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79702
79703   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79704   {
79705     try {
79706       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79707     } catch (std::out_of_range& e) {
79708       {
79709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79710       };
79711     } catch (std::exception& e) {
79712       {
79713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79714       };
79715     } catch (...) {
79716       {
79717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79718       };
79719     }
79720   }
79721   jresult = (void *)result;
79722   return jresult;
79723 }
79724
79725
79726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79727   void * jresult ;
79728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79729   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79730
79731   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79732   {
79733     try {
79734       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79735     } catch (std::out_of_range& e) {
79736       {
79737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79738       };
79739     } catch (std::exception& e) {
79740       {
79741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (...) {
79744       {
79745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79746       };
79747     }
79748   }
79749   jresult = (void *)result;
79750   return jresult;
79751 }
79752
79753
79754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79755   void * jresult ;
79756   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79757   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79758
79759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79760   {
79761     try {
79762       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79763     } catch (std::out_of_range& e) {
79764       {
79765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79766       };
79767     } catch (std::exception& e) {
79768       {
79769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79770       };
79771     } catch (...) {
79772       {
79773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79774       };
79775     }
79776   }
79777   jresult = (void *)result;
79778   return jresult;
79779 }
79780
79781
79782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79783   void * jresult ;
79784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79785   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79786
79787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79788   {
79789     try {
79790       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79791     } catch (std::out_of_range& e) {
79792       {
79793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (std::exception& e) {
79796       {
79797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79802       };
79803     }
79804   }
79805   jresult = (void *)result;
79806   return jresult;
79807 }
79808
79809
79810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79811   void * jresult ;
79812   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79813   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79814
79815   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79816   {
79817     try {
79818       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79819     } catch (std::out_of_range& e) {
79820       {
79821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79822       };
79823     } catch (std::exception& e) {
79824       {
79825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79826       };
79827     } catch (...) {
79828       {
79829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79830       };
79831     }
79832   }
79833   jresult = (void *)result;
79834   return jresult;
79835 }
79836
79837
79838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79839   void * jresult ;
79840   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79841   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79842
79843   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79844   {
79845     try {
79846       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79847     } catch (std::out_of_range& e) {
79848       {
79849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (std::exception& e) {
79852       {
79853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (...) {
79856       {
79857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79858       };
79859     }
79860   }
79861   jresult = (void *)result;
79862   return jresult;
79863 }
79864
79865
79866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79867   void * jresult ;
79868   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79869   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79870
79871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79872   {
79873     try {
79874       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79875     } catch (std::out_of_range& e) {
79876       {
79877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79878       };
79879     } catch (std::exception& e) {
79880       {
79881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79882       };
79883     } catch (...) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79886       };
79887     }
79888   }
79889   jresult = (void *)result;
79890   return jresult;
79891 }
79892
79893
79894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79895   void * jresult ;
79896   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79897   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79898
79899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79900   {
79901     try {
79902       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79903     } catch (std::out_of_range& e) {
79904       {
79905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (std::exception& e) {
79908       {
79909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79910       };
79911     } catch (...) {
79912       {
79913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79914       };
79915     }
79916   }
79917   jresult = (void *)result;
79918   return jresult;
79919 }
79920
79921
79922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79923   void * jresult ;
79924   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79925   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79926
79927   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79928   {
79929     try {
79930       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79931     } catch (std::out_of_range& e) {
79932       {
79933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79934       };
79935     } catch (std::exception& e) {
79936       {
79937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79938       };
79939     } catch (...) {
79940       {
79941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79942       };
79943     }
79944   }
79945   jresult = (void *)result;
79946   return jresult;
79947 }
79948
79949
79950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79951   void * jresult ;
79952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79953   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79954
79955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79956   {
79957     try {
79958       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79959     } catch (std::out_of_range& e) {
79960       {
79961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79962       };
79963     } catch (std::exception& e) {
79964       {
79965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79966       };
79967     } catch (...) {
79968       {
79969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79970       };
79971     }
79972   }
79973   jresult = (void *)result;
79974   return jresult;
79975 }
79976
79977
79978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79979   void * jresult ;
79980   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79981   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79982
79983   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79984   {
79985     try {
79986       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79987     } catch (std::out_of_range& e) {
79988       {
79989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (std::exception& e) {
79992       {
79993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79994       };
79995     } catch (...) {
79996       {
79997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79998       };
79999     }
80000   }
80001   jresult = (void *)result;
80002   return jresult;
80003 }
80004
80005
80006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80007   void * jresult ;
80008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80009   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80010
80011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80012   {
80013     try {
80014       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80015     } catch (std::out_of_range& e) {
80016       {
80017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80018       };
80019     } catch (std::exception& e) {
80020       {
80021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80022       };
80023     } catch (...) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80026       };
80027     }
80028   }
80029   jresult = (void *)result;
80030   return jresult;
80031 }
80032
80033
80034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80035   void * jresult ;
80036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80037   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80038
80039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80040   {
80041     try {
80042       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80043     } catch (std::out_of_range& e) {
80044       {
80045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (std::exception& e) {
80048       {
80049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80050       };
80051     } catch (...) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80054       };
80055     }
80056   }
80057   jresult = (void *)result;
80058   return jresult;
80059 }
80060
80061
80062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80063   void * jresult ;
80064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80065   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80066
80067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80068   {
80069     try {
80070       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80071     } catch (std::out_of_range& e) {
80072       {
80073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (std::exception& e) {
80076       {
80077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (...) {
80080       {
80081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80082       };
80083     }
80084   }
80085   jresult = (void *)result;
80086   return jresult;
80087 }
80088
80089
80090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80091   void * jresult ;
80092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80093   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80094
80095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80096   {
80097     try {
80098       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80099     } catch (std::out_of_range& e) {
80100       {
80101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80102       };
80103     } catch (std::exception& e) {
80104       {
80105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80106       };
80107     } catch (...) {
80108       {
80109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80110       };
80111     }
80112   }
80113   jresult = (void *)result;
80114   return jresult;
80115 }
80116
80117
80118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80119   void * jresult ;
80120   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80121   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80122
80123   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80124   {
80125     try {
80126       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80127     } catch (std::out_of_range& e) {
80128       {
80129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80130       };
80131     } catch (std::exception& e) {
80132       {
80133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80134       };
80135     } catch (...) {
80136       {
80137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80138       };
80139     }
80140   }
80141   jresult = (void *)result;
80142   return jresult;
80143 }
80144
80145
80146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80147   void * jresult ;
80148   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80149   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80150
80151   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80152   {
80153     try {
80154       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80155     } catch (std::out_of_range& e) {
80156       {
80157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80158       };
80159     } catch (std::exception& e) {
80160       {
80161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80162       };
80163     } catch (...) {
80164       {
80165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80166       };
80167     }
80168   }
80169   jresult = (void *)result;
80170   return jresult;
80171 }
80172
80173
80174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80175   void * jresult ;
80176   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80177   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80178
80179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80180   {
80181     try {
80182       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80183     } catch (std::out_of_range& e) {
80184       {
80185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80186       };
80187     } catch (std::exception& e) {
80188       {
80189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80190       };
80191     } catch (...) {
80192       {
80193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80194       };
80195     }
80196   }
80197   jresult = (void *)result;
80198   return jresult;
80199 }
80200
80201
80202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80203   void * jresult ;
80204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80205   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80206
80207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80208   {
80209     try {
80210       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80211     } catch (std::out_of_range& e) {
80212       {
80213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80214       };
80215     } catch (std::exception& e) {
80216       {
80217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80218       };
80219     } catch (...) {
80220       {
80221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80222       };
80223     }
80224   }
80225   jresult = (void *)result;
80226   return jresult;
80227 }
80228
80229
80230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80231   void * jresult ;
80232   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80233   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80234
80235   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80236   {
80237     try {
80238       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80239     } catch (std::out_of_range& e) {
80240       {
80241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80242       };
80243     } catch (std::exception& e) {
80244       {
80245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80246       };
80247     } catch (...) {
80248       {
80249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80250       };
80251     }
80252   }
80253   jresult = (void *)result;
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80259   void * jresult ;
80260   Dali::Toolkit::StyleManager *result = 0 ;
80261
80262   {
80263     try {
80264       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80265     } catch (std::out_of_range& e) {
80266       {
80267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80268       };
80269     } catch (std::exception& e) {
80270       {
80271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (...) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80276       };
80277     }
80278   }
80279   jresult = (void *)result;
80280   return jresult;
80281 }
80282
80283
80284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80285   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80286
80287   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80288   {
80289     try {
80290       delete arg1;
80291     } catch (std::out_of_range& e) {
80292       {
80293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80294       };
80295     } catch (std::exception& e) {
80296       {
80297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80298       };
80299     } catch (...) {
80300       {
80301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80302       };
80303     }
80304   }
80305 }
80306
80307
80308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80309   void * jresult ;
80310   Dali::Toolkit::StyleManager result;
80311
80312   {
80313     try {
80314       result = Dali::Toolkit::StyleManager::Get();
80315     } catch (std::out_of_range& e) {
80316       {
80317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80318       };
80319     } catch (std::exception& e) {
80320       {
80321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80322       };
80323     } catch (...) {
80324       {
80325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80326       };
80327     }
80328   }
80329   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80330   return jresult;
80331 }
80332
80333
80334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80335   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80336   std::string *arg2 = 0 ;
80337
80338   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80339   if (!jarg2) {
80340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80341     return ;
80342   }
80343   std::string arg2_str(jarg2);
80344   arg2 = &arg2_str;
80345   {
80346     try {
80347       (arg1)->ApplyTheme((std::string const &)*arg2);
80348     } catch (std::out_of_range& e) {
80349       {
80350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80351       };
80352     } catch (std::exception& e) {
80353       {
80354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80355       };
80356     } catch (...) {
80357       {
80358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80359       };
80360     }
80361   }
80362
80363   //argout typemap for const std::string&
80364
80365 }
80366
80367
80368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80369   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80370
80371   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80372   {
80373     try {
80374       (arg1)->ApplyDefaultTheme();
80375     } catch (std::out_of_range& e) {
80376       {
80377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80378       };
80379     } catch (std::exception& e) {
80380       {
80381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80382       };
80383     } catch (...) {
80384       {
80385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80386       };
80387     }
80388   }
80389 }
80390
80391
80392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80393   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80394   std::string *arg2 = 0 ;
80395   Dali::Property::Value *arg3 = 0 ;
80396
80397   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80398   if (!jarg2) {
80399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80400     return ;
80401   }
80402   std::string arg2_str(jarg2);
80403   arg2 = &arg2_str;
80404   arg3 = (Dali::Property::Value *)jarg3;
80405   if (!arg3) {
80406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80407     return ;
80408   }
80409   {
80410     try {
80411       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80412     } catch (std::out_of_range& e) {
80413       {
80414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80415       };
80416     } catch (std::exception& e) {
80417       {
80418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80419       };
80420     } catch (...) {
80421       {
80422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80423       };
80424     }
80425   }
80426
80427   //argout typemap for const std::string&
80428
80429 }
80430
80431
80432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80433   unsigned int jresult ;
80434   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80435   std::string *arg2 = 0 ;
80436   Dali::Property::Value *arg3 = 0 ;
80437   bool result;
80438
80439   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80440   if (!jarg2) {
80441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80442     return 0;
80443   }
80444   std::string arg2_str(jarg2);
80445   arg2 = &arg2_str;
80446   arg3 = (Dali::Property::Value *)jarg3;
80447   if (!arg3) {
80448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80449     return 0;
80450   }
80451   {
80452     try {
80453       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80454     } catch (std::out_of_range& e) {
80455       {
80456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80457       };
80458     } catch (std::exception& e) {
80459       {
80460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80461       };
80462     } catch (...) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80465       };
80466     }
80467   }
80468   jresult = result;
80469
80470   //argout typemap for const std::string&
80471
80472   return jresult;
80473 }
80474
80475
80476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80477   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80478   Dali::Toolkit::Control arg2 ;
80479   std::string *arg3 = 0 ;
80480   std::string *arg4 = 0 ;
80481   Dali::Toolkit::Control *argp2 ;
80482
80483   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80484   argp2 = (Dali::Toolkit::Control *)jarg2;
80485   if (!argp2) {
80486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80487     return ;
80488   }
80489   arg2 = *argp2;
80490   if (!jarg3) {
80491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80492     return ;
80493   }
80494   std::string arg3_str(jarg3);
80495   arg3 = &arg3_str;
80496   if (!jarg4) {
80497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80498     return ;
80499   }
80500   std::string arg4_str(jarg4);
80501   arg4 = &arg4_str;
80502   {
80503     try {
80504       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80505     } catch (std::out_of_range& e) {
80506       {
80507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80508       };
80509     } catch (std::exception& e) {
80510       {
80511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80512       };
80513     } catch (...) {
80514       {
80515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80516       };
80517     }
80518   }
80519
80520   //argout typemap for const std::string&
80521
80522
80523   //argout typemap for const std::string&
80524
80525 }
80526
80527
80528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80529   void * jresult ;
80530   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80531   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80532
80533   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80534   {
80535     try {
80536       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80537     } catch (std::out_of_range& e) {
80538       {
80539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80540       };
80541     } catch (std::exception& e) {
80542       {
80543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80544       };
80545     } catch (...) {
80546       {
80547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80548       };
80549     }
80550   }
80551   jresult = (void *)result;
80552   return jresult;
80553 }
80554
80555
80556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80557   int jresult ;
80558   int result;
80559
80560   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80561   jresult = (int)result;
80562   return jresult;
80563 }
80564
80565
80566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80567   int jresult ;
80568   int result;
80569
80570   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80571   jresult = (int)result;
80572   return jresult;
80573 }
80574
80575
80576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80577   int jresult ;
80578   int result;
80579
80580   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80581   jresult = (int)result;
80582   return jresult;
80583 }
80584
80585
80586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80587   int jresult ;
80588   int result;
80589
80590   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80591   jresult = (int)result;
80592   return jresult;
80593 }
80594
80595
80596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80597   int jresult ;
80598   int result;
80599
80600   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80601   jresult = (int)result;
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80607   int jresult ;
80608   int result;
80609
80610   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80611   jresult = (int)result;
80612   return jresult;
80613 }
80614
80615
80616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80617   int jresult ;
80618   int result;
80619
80620   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80621   jresult = (int)result;
80622   return jresult;
80623 }
80624
80625
80626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80627   int jresult ;
80628   int result;
80629
80630   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80631   jresult = (int)result;
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80637   int jresult ;
80638   int result;
80639
80640   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80641   jresult = (int)result;
80642   return jresult;
80643 }
80644
80645
80646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80647   int jresult ;
80648   int result;
80649
80650   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80651   jresult = (int)result;
80652   return jresult;
80653 }
80654
80655
80656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80657   int jresult ;
80658   int result;
80659
80660   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80661   jresult = (int)result;
80662   return jresult;
80663 }
80664
80665
80666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80667   int jresult ;
80668   int result;
80669
80670   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80671   jresult = (int)result;
80672   return jresult;
80673 }
80674
80675
80676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80677   int jresult ;
80678   int result;
80679
80680   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80681   jresult = (int)result;
80682   return jresult;
80683 }
80684
80685
80686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80687   int jresult ;
80688   int result;
80689
80690   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80691   jresult = (int)result;
80692   return jresult;
80693 }
80694
80695
80696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80697   int jresult ;
80698   int result;
80699
80700   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80701   jresult = (int)result;
80702   return jresult;
80703 }
80704
80705
80706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80707   void * jresult ;
80708   Dali::Toolkit::Slider::Property *result = 0 ;
80709
80710   {
80711     try {
80712       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80713     } catch (std::out_of_range& e) {
80714       {
80715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80716       };
80717     } catch (std::exception& e) {
80718       {
80719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80724       };
80725     }
80726   }
80727   jresult = (void *)result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80733   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80734
80735   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80736   {
80737     try {
80738       delete arg1;
80739     } catch (std::out_of_range& e) {
80740       {
80741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80742       };
80743     } catch (std::exception& e) {
80744       {
80745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80746       };
80747     } catch (...) {
80748       {
80749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80750       };
80751     }
80752   }
80753 }
80754
80755
80756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80757   void * jresult ;
80758   Dali::Toolkit::Slider result;
80759
80760   {
80761     try {
80762       result = Dali::Toolkit::Slider::New();
80763     } catch (std::out_of_range& e) {
80764       {
80765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80766       };
80767     } catch (std::exception& e) {
80768       {
80769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80770       };
80771     } catch (...) {
80772       {
80773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80774       };
80775     }
80776   }
80777   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80778   return jresult;
80779 }
80780
80781
80782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80783   void * jresult ;
80784   Dali::Toolkit::Slider *result = 0 ;
80785
80786   {
80787     try {
80788       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80789     } catch (std::out_of_range& e) {
80790       {
80791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80792       };
80793     } catch (std::exception& e) {
80794       {
80795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80796       };
80797     } catch (...) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80800       };
80801     }
80802   }
80803   jresult = (void *)result;
80804   return jresult;
80805 }
80806
80807
80808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80809   void * jresult ;
80810   Dali::Toolkit::Slider *arg1 = 0 ;
80811   Dali::Toolkit::Slider *result = 0 ;
80812
80813   arg1 = (Dali::Toolkit::Slider *)jarg1;
80814   if (!arg1) {
80815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80816     return 0;
80817   }
80818   {
80819     try {
80820       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80821     } catch (std::out_of_range& e) {
80822       {
80823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80824       };
80825     } catch (std::exception& e) {
80826       {
80827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (...) {
80830       {
80831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80832       };
80833     }
80834   }
80835   jresult = (void *)result;
80836   return jresult;
80837 }
80838
80839
80840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80841   void * jresult ;
80842   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80843   Dali::Toolkit::Slider *arg2 = 0 ;
80844   Dali::Toolkit::Slider *result = 0 ;
80845
80846   arg1 = (Dali::Toolkit::Slider *)jarg1;
80847   arg2 = (Dali::Toolkit::Slider *)jarg2;
80848   if (!arg2) {
80849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80850     return 0;
80851   }
80852   {
80853     try {
80854       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (...) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80866       };
80867     }
80868   }
80869   jresult = (void *)result;
80870   return jresult;
80871 }
80872
80873
80874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80875   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80876
80877   arg1 = (Dali::Toolkit::Slider *)jarg1;
80878   {
80879     try {
80880       delete arg1;
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80888       };
80889     } catch (...) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80892       };
80893     }
80894   }
80895 }
80896
80897
80898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80899   void * jresult ;
80900   Dali::BaseHandle arg1 ;
80901   Dali::BaseHandle *argp1 ;
80902   Dali::Toolkit::Slider result;
80903
80904   argp1 = (Dali::BaseHandle *)jarg1;
80905   if (!argp1) {
80906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80907     return 0;
80908   }
80909   arg1 = *argp1;
80910   {
80911     try {
80912       result = Dali::Toolkit::Slider::DownCast(arg1);
80913     } catch (std::out_of_range& e) {
80914       {
80915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80916       };
80917     } catch (std::exception& e) {
80918       {
80919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80920       };
80921     } catch (...) {
80922       {
80923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80924       };
80925     }
80926   }
80927   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80928   return jresult;
80929 }
80930
80931
80932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80933   void * jresult ;
80934   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80935   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80936
80937   arg1 = (Dali::Toolkit::Slider *)jarg1;
80938   {
80939     try {
80940       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80941     } catch (std::out_of_range& e) {
80942       {
80943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80944       };
80945     } catch (std::exception& e) {
80946       {
80947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80948       };
80949     } catch (...) {
80950       {
80951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80952       };
80953     }
80954   }
80955   jresult = (void *)result;
80956   return jresult;
80957 }
80958
80959
80960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80961   void * jresult ;
80962   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80963   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80964
80965   arg1 = (Dali::Toolkit::Slider *)jarg1;
80966   {
80967     try {
80968       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80969     } catch (std::out_of_range& e) {
80970       {
80971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80972       };
80973     } catch (std::exception& e) {
80974       {
80975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80976       };
80977     } catch (...) {
80978       {
80979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80980       };
80981     }
80982   }
80983   jresult = (void *)result;
80984   return jresult;
80985 }
80986
80987
80988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80989   void * jresult ;
80990   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80991   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80992
80993   arg1 = (Dali::Toolkit::Slider *)jarg1;
80994   {
80995     try {
80996       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80997     } catch (std::out_of_range& e) {
80998       {
80999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81000       };
81001     } catch (std::exception& e) {
81002       {
81003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81004       };
81005     } catch (...) {
81006       {
81007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81008       };
81009     }
81010   }
81011   jresult = (void *)result;
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81017   int jresult ;
81018   int result;
81019
81020   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81021   jresult = (int)result;
81022   return jresult;
81023 }
81024
81025
81026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81027   int jresult ;
81028   int result;
81029
81030   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81031   jresult = (int)result;
81032   return jresult;
81033 }
81034
81035
81036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81037   int jresult ;
81038   int result;
81039
81040   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81041   jresult = (int)result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81047   int jresult ;
81048   int result;
81049
81050   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81051   jresult = (int)result;
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81057   void * jresult ;
81058   Dali::Toolkit::VideoView::Property *result = 0 ;
81059
81060   {
81061     try {
81062       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81063     } catch (std::out_of_range& e) {
81064       {
81065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (std::exception& e) {
81068       {
81069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81070       };
81071     } catch (...) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81074       };
81075     }
81076   }
81077   jresult = (void *)result;
81078   return jresult;
81079 }
81080
81081
81082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81083   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81084
81085   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81086   {
81087     try {
81088       delete arg1;
81089     } catch (std::out_of_range& e) {
81090       {
81091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81092       };
81093     } catch (std::exception& e) {
81094       {
81095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81096       };
81097     } catch (...) {
81098       {
81099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81100       };
81101     }
81102   }
81103 }
81104
81105
81106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81107   void * jresult ;
81108   Dali::Toolkit::VideoView result;
81109
81110   {
81111     try {
81112       result = Dali::Toolkit::VideoView::New();
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (...) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81124       };
81125     }
81126   }
81127   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81128   return jresult;
81129 }
81130
81131
81132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81133   void * jresult ;
81134   std::string *arg1 = 0 ;
81135   Dali::Toolkit::VideoView result;
81136
81137   if (!jarg1) {
81138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81139     return 0;
81140   }
81141   std::string arg1_str(jarg1);
81142   arg1 = &arg1_str;
81143   {
81144     try {
81145       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81146     } catch (std::out_of_range& e) {
81147       {
81148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81149       };
81150     } catch (std::exception& e) {
81151       {
81152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81153       };
81154     } catch (...) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81157       };
81158     }
81159   }
81160   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81161
81162   //argout typemap for const std::string&
81163
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81169   void * jresult ;
81170   Dali::Toolkit::VideoView *result = 0 ;
81171
81172   {
81173     try {
81174       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81175     } catch (std::out_of_range& e) {
81176       {
81177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81178       };
81179     } catch (std::exception& e) {
81180       {
81181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81182       };
81183     } catch (...) {
81184       {
81185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81186       };
81187     }
81188   }
81189   jresult = (void *)result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81195   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81196
81197   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81198   {
81199     try {
81200       delete arg1;
81201     } catch (std::out_of_range& e) {
81202       {
81203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81204       };
81205     } catch (std::exception& e) {
81206       {
81207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81208       };
81209     } catch (...) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81212       };
81213     }
81214   }
81215 }
81216
81217
81218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81219   void * jresult ;
81220   Dali::Toolkit::VideoView *arg1 = 0 ;
81221   Dali::Toolkit::VideoView *result = 0 ;
81222
81223   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81224   if (!arg1) {
81225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81226     return 0;
81227   }
81228   {
81229     try {
81230       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81231     } catch (std::out_of_range& e) {
81232       {
81233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (std::exception& e) {
81236       {
81237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81238       };
81239     } catch (...) {
81240       {
81241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81242       };
81243     }
81244   }
81245   jresult = (void *)result;
81246   return jresult;
81247 }
81248
81249
81250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81251   void * jresult ;
81252   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81253   Dali::Toolkit::VideoView *arg2 = 0 ;
81254   Dali::Toolkit::VideoView *result = 0 ;
81255
81256   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81257   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81258   if (!arg2) {
81259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81260     return 0;
81261   }
81262   {
81263     try {
81264       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81265     } catch (std::out_of_range& e) {
81266       {
81267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81268       };
81269     } catch (std::exception& e) {
81270       {
81271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81272       };
81273     } catch (...) {
81274       {
81275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81276       };
81277     }
81278   }
81279   jresult = (void *)result;
81280   return jresult;
81281 }
81282
81283
81284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81285   void * jresult ;
81286   Dali::BaseHandle arg1 ;
81287   Dali::BaseHandle *argp1 ;
81288   Dali::Toolkit::VideoView result;
81289
81290   argp1 = (Dali::BaseHandle *)jarg1;
81291   if (!argp1) {
81292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81293     return 0;
81294   }
81295   arg1 = *argp1;
81296   {
81297     try {
81298       result = Dali::Toolkit::VideoView::DownCast(arg1);
81299     } catch (std::out_of_range& e) {
81300       {
81301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81302       };
81303     } catch (std::exception& e) {
81304       {
81305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81306       };
81307     } catch (...) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81310       };
81311     }
81312   }
81313   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81314   return jresult;
81315 }
81316
81317
81318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81319   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81320
81321   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81322   {
81323     try {
81324       (arg1)->Play();
81325     } catch (std::out_of_range& e) {
81326       {
81327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81328       };
81329     } catch (std::exception& e) {
81330       {
81331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81332       };
81333     } catch (...) {
81334       {
81335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81336       };
81337     }
81338   }
81339 }
81340
81341
81342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81343   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81344
81345   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81346   {
81347     try {
81348       (arg1)->Pause();
81349     } catch (std::out_of_range& e) {
81350       {
81351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81352       };
81353     } catch (std::exception& e) {
81354       {
81355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81356       };
81357     } catch (...) {
81358       {
81359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81360       };
81361     }
81362   }
81363 }
81364
81365
81366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81367   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81368
81369   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81370   {
81371     try {
81372       (arg1)->Stop();
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81380       };
81381     } catch (...) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81384       };
81385     }
81386   }
81387 }
81388
81389
81390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81391   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81392   int arg2 ;
81393
81394   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81395   arg2 = (int)jarg2;
81396   {
81397     try {
81398       (arg1)->Forward(arg2);
81399     } catch (std::out_of_range& e) {
81400       {
81401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81402       };
81403     } catch (std::exception& e) {
81404       {
81405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81406       };
81407     } catch (...) {
81408       {
81409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81410       };
81411     }
81412   }
81413 }
81414
81415
81416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81417   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81418   int arg2 ;
81419
81420   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81421   arg2 = (int)jarg2;
81422   {
81423     try {
81424       (arg1)->Backward(arg2);
81425     } catch (std::out_of_range& e) {
81426       {
81427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81428       };
81429     } catch (std::exception& e) {
81430       {
81431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81432       };
81433     } catch (...) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81436       };
81437     }
81438   }
81439 }
81440
81441
81442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81443   void * jresult ;
81444   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81445   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81446
81447   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81448   {
81449     try {
81450       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81451     } catch (std::out_of_range& e) {
81452       {
81453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81454       };
81455     } catch (std::exception& e) {
81456       {
81457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81458       };
81459     } catch (...) {
81460       {
81461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81462       };
81463     }
81464   }
81465   jresult = (void *)result;
81466   return jresult;
81467 }
81468
81469
81470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81471   int jresult ;
81472   int result;
81473
81474   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81475   jresult = (int)result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81481   int jresult ;
81482   int result;
81483
81484   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81485   jresult = (int)result;
81486   return jresult;
81487 }
81488
81489
81490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81491   int jresult ;
81492   int result;
81493
81494   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81495   jresult = (int)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81501   int jresult ;
81502   int result;
81503
81504   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81505   jresult = (int)result;
81506   return jresult;
81507 }
81508
81509
81510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81511   int jresult ;
81512   int result;
81513
81514   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81515   jresult = (int)result;
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81521   int jresult ;
81522   int result;
81523
81524   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81525   jresult = (int)result;
81526   return jresult;
81527 }
81528
81529
81530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81531   int jresult ;
81532   int result;
81533
81534   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81535   jresult = (int)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81541   int jresult ;
81542   int result;
81543
81544   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81545   jresult = (int)result;
81546   return jresult;
81547 }
81548
81549
81550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81551   int jresult ;
81552   int result;
81553
81554   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81555   jresult = (int)result;
81556   return jresult;
81557 }
81558
81559
81560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81561   int jresult ;
81562   int result;
81563
81564   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81565   jresult = (int)result;
81566   return jresult;
81567 }
81568
81569
81570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81571   int jresult ;
81572   int result;
81573
81574   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81575   jresult = (int)result;
81576   return jresult;
81577 }
81578
81579
81580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81581   int jresult ;
81582   int result;
81583
81584   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81585   jresult = (int)result;
81586   return jresult;
81587 }
81588
81589
81590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81591   int jresult ;
81592   int result;
81593
81594   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81595   jresult = (int)result;
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81601   int jresult ;
81602   int result;
81603
81604   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81605   jresult = (int)result;
81606   return jresult;
81607 }
81608
81609
81610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81611   int jresult ;
81612   int result;
81613
81614   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81615   jresult = (int)result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81621   int jresult ;
81622   int result;
81623
81624   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81625   jresult = (int)result;
81626   return jresult;
81627 }
81628
81629
81630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81631   int jresult ;
81632   int result;
81633
81634   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81635   jresult = (int)result;
81636   return jresult;
81637 }
81638
81639
81640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81641   int jresult ;
81642   int result;
81643
81644   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81645   jresult = (int)result;
81646   return jresult;
81647 }
81648
81649
81650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81651   int jresult ;
81652   int result;
81653
81654   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81655   jresult = (int)result;
81656   return jresult;
81657 }
81658
81659
81660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81661   int jresult ;
81662   int result;
81663
81664   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81665   jresult = (int)result;
81666   return jresult;
81667 }
81668
81669
81670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81671   int jresult ;
81672   int result;
81673
81674   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81675   jresult = (int)result;
81676   return jresult;
81677 }
81678
81679
81680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81681   void * jresult ;
81682   Dali::Toolkit::Popup::Property *result = 0 ;
81683
81684   {
81685     try {
81686       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81687     } catch (std::out_of_range& e) {
81688       {
81689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81690       };
81691     } catch (std::exception& e) {
81692       {
81693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81698       };
81699     }
81700   }
81701   jresult = (void *)result;
81702   return jresult;
81703 }
81704
81705
81706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81707   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81708
81709   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81710   {
81711     try {
81712       delete arg1;
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81724       };
81725     }
81726   }
81727 }
81728
81729
81730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81731   void * jresult ;
81732   Dali::Toolkit::Popup *result = 0 ;
81733
81734   {
81735     try {
81736       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81737     } catch (std::out_of_range& e) {
81738       {
81739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81740       };
81741     } catch (std::exception& e) {
81742       {
81743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81744       };
81745     } catch (...) {
81746       {
81747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81748       };
81749     }
81750   }
81751   jresult = (void *)result;
81752   return jresult;
81753 }
81754
81755
81756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81757   void * jresult ;
81758   Dali::Toolkit::Popup result;
81759
81760   {
81761     try {
81762       result = Dali::Toolkit::Popup::New();
81763     } catch (std::out_of_range& e) {
81764       {
81765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81766       };
81767     } catch (std::exception& e) {
81768       {
81769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81770       };
81771     } catch (...) {
81772       {
81773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81774       };
81775     }
81776   }
81777   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81778   return jresult;
81779 }
81780
81781
81782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81783   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81784
81785   arg1 = (Dali::Toolkit::Popup *)jarg1;
81786   {
81787     try {
81788       delete arg1;
81789     } catch (std::out_of_range& e) {
81790       {
81791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81792       };
81793     } catch (std::exception& e) {
81794       {
81795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81796       };
81797     } catch (...) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81800       };
81801     }
81802   }
81803 }
81804
81805
81806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81807   void * jresult ;
81808   Dali::Toolkit::Popup *arg1 = 0 ;
81809   Dali::Toolkit::Popup *result = 0 ;
81810
81811   arg1 = (Dali::Toolkit::Popup *)jarg1;
81812   if (!arg1) {
81813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81814     return 0;
81815   }
81816   {
81817     try {
81818       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81819     } catch (std::out_of_range& e) {
81820       {
81821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81822       };
81823     } catch (std::exception& e) {
81824       {
81825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81826       };
81827     } catch (...) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81830       };
81831     }
81832   }
81833   jresult = (void *)result;
81834   return jresult;
81835 }
81836
81837
81838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81839   void * jresult ;
81840   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81841   Dali::Toolkit::Popup *arg2 = 0 ;
81842   Dali::Toolkit::Popup *result = 0 ;
81843
81844   arg1 = (Dali::Toolkit::Popup *)jarg1;
81845   arg2 = (Dali::Toolkit::Popup *)jarg2;
81846   if (!arg2) {
81847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81848     return 0;
81849   }
81850   {
81851     try {
81852       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81853     } catch (std::out_of_range& e) {
81854       {
81855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81856       };
81857     } catch (std::exception& e) {
81858       {
81859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81860       };
81861     } catch (...) {
81862       {
81863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81864       };
81865     }
81866   }
81867   jresult = (void *)result;
81868   return jresult;
81869 }
81870
81871
81872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81873   void * jresult ;
81874   Dali::BaseHandle arg1 ;
81875   Dali::BaseHandle *argp1 ;
81876   Dali::Toolkit::Popup result;
81877
81878   argp1 = (Dali::BaseHandle *)jarg1;
81879   if (!argp1) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81881     return 0;
81882   }
81883   arg1 = *argp1;
81884   {
81885     try {
81886       result = Dali::Toolkit::Popup::DownCast(arg1);
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81894       };
81895     } catch (...) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81898       };
81899     }
81900   }
81901   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81902   return jresult;
81903 }
81904
81905
81906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81907   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81908   Dali::Actor arg2 ;
81909   Dali::Actor *argp2 ;
81910
81911   arg1 = (Dali::Toolkit::Popup *)jarg1;
81912   argp2 = (Dali::Actor *)jarg2;
81913   if (!argp2) {
81914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81915     return ;
81916   }
81917   arg2 = *argp2;
81918   {
81919     try {
81920       (arg1)->SetTitle(arg2);
81921     } catch (std::out_of_range& e) {
81922       {
81923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81924       };
81925     } catch (std::exception& e) {
81926       {
81927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81928       };
81929     } catch (...) {
81930       {
81931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81932       };
81933     }
81934   }
81935 }
81936
81937
81938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81939   void * jresult ;
81940   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81941   Dali::Actor result;
81942
81943   arg1 = (Dali::Toolkit::Popup *)jarg1;
81944   {
81945     try {
81946       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81947     } catch (std::out_of_range& e) {
81948       {
81949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81950       };
81951     } catch (std::exception& e) {
81952       {
81953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (...) {
81956       {
81957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81958       };
81959     }
81960   }
81961   jresult = new Dali::Actor((const Dali::Actor &)result);
81962   return jresult;
81963 }
81964
81965
81966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81967   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81968   Dali::Actor arg2 ;
81969   Dali::Actor *argp2 ;
81970
81971   arg1 = (Dali::Toolkit::Popup *)jarg1;
81972   argp2 = (Dali::Actor *)jarg2;
81973   if (!argp2) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81975     return ;
81976   }
81977   arg2 = *argp2;
81978   {
81979     try {
81980       (arg1)->SetContent(arg2);
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81992       };
81993     }
81994   }
81995 }
81996
81997
81998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81999   void * jresult ;
82000   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82001   Dali::Actor result;
82002
82003   arg1 = (Dali::Toolkit::Popup *)jarg1;
82004   {
82005     try {
82006       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82007     } catch (std::out_of_range& e) {
82008       {
82009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82010       };
82011     } catch (std::exception& e) {
82012       {
82013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82014       };
82015     } catch (...) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82018       };
82019     }
82020   }
82021   jresult = new Dali::Actor((const Dali::Actor &)result);
82022   return jresult;
82023 }
82024
82025
82026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82027   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82028   Dali::Actor arg2 ;
82029   Dali::Actor *argp2 ;
82030
82031   arg1 = (Dali::Toolkit::Popup *)jarg1;
82032   argp2 = (Dali::Actor *)jarg2;
82033   if (!argp2) {
82034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82035     return ;
82036   }
82037   arg2 = *argp2;
82038   {
82039     try {
82040       (arg1)->SetFooter(arg2);
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82052       };
82053     }
82054   }
82055 }
82056
82057
82058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82059   void * jresult ;
82060   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82061   Dali::Actor result;
82062
82063   arg1 = (Dali::Toolkit::Popup *)jarg1;
82064   {
82065     try {
82066       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82067     } catch (std::out_of_range& e) {
82068       {
82069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82070       };
82071     } catch (std::exception& e) {
82072       {
82073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82074       };
82075     } catch (...) {
82076       {
82077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82078       };
82079     }
82080   }
82081   jresult = new Dali::Actor((const Dali::Actor &)result);
82082   return jresult;
82083 }
82084
82085
82086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82087   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82088   Dali::Toolkit::Popup::DisplayState arg2 ;
82089
82090   arg1 = (Dali::Toolkit::Popup *)jarg1;
82091   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82092   {
82093     try {
82094       (arg1)->SetDisplayState(arg2);
82095     } catch (std::out_of_range& e) {
82096       {
82097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82098       };
82099     } catch (std::exception& e) {
82100       {
82101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (...) {
82104       {
82105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82106       };
82107     }
82108   }
82109 }
82110
82111
82112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82113   int jresult ;
82114   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82115   Dali::Toolkit::Popup::DisplayState result;
82116
82117   arg1 = (Dali::Toolkit::Popup *)jarg1;
82118   {
82119     try {
82120       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82121     } catch (std::out_of_range& e) {
82122       {
82123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82124       };
82125     } catch (std::exception& e) {
82126       {
82127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82128       };
82129     } catch (...) {
82130       {
82131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82132       };
82133     }
82134   }
82135   jresult = (int)result;
82136   return jresult;
82137 }
82138
82139
82140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82141   void * jresult ;
82142   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82143   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82144
82145   arg1 = (Dali::Toolkit::Popup *)jarg1;
82146   {
82147     try {
82148       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82149     } catch (std::out_of_range& e) {
82150       {
82151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (std::exception& e) {
82154       {
82155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82160       };
82161     }
82162   }
82163   jresult = (void *)result;
82164   return jresult;
82165 }
82166
82167
82168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82169   void * jresult ;
82170   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82171   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82172
82173   arg1 = (Dali::Toolkit::Popup *)jarg1;
82174   {
82175     try {
82176       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82177     } catch (std::out_of_range& e) {
82178       {
82179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82180       };
82181     } catch (std::exception& e) {
82182       {
82183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82184       };
82185     } catch (...) {
82186       {
82187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82188       };
82189     }
82190   }
82191   jresult = (void *)result;
82192   return jresult;
82193 }
82194
82195
82196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82197   void * jresult ;
82198   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82199   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82200
82201   arg1 = (Dali::Toolkit::Popup *)jarg1;
82202   {
82203     try {
82204       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82205     } catch (std::out_of_range& e) {
82206       {
82207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82208       };
82209     } catch (std::exception& e) {
82210       {
82211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82212       };
82213     } catch (...) {
82214       {
82215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82216       };
82217     }
82218   }
82219   jresult = (void *)result;
82220   return jresult;
82221 }
82222
82223
82224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82225   void * jresult ;
82226   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82227   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82228
82229   arg1 = (Dali::Toolkit::Popup *)jarg1;
82230   {
82231     try {
82232       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82233     } catch (std::out_of_range& e) {
82234       {
82235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82236       };
82237     } catch (std::exception& e) {
82238       {
82239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82240       };
82241     } catch (...) {
82242       {
82243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82244       };
82245     }
82246   }
82247   jresult = (void *)result;
82248   return jresult;
82249 }
82250
82251
82252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82253   void * jresult ;
82254   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82255   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82256
82257   arg1 = (Dali::Toolkit::Popup *)jarg1;
82258   {
82259     try {
82260       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82261     } catch (std::out_of_range& e) {
82262       {
82263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82264       };
82265     } catch (std::exception& e) {
82266       {
82267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82268       };
82269     } catch (...) {
82270       {
82271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82272       };
82273     }
82274   }
82275   jresult = (void *)result;
82276   return jresult;
82277 }
82278
82279
82280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82281   int jresult ;
82282   int result;
82283
82284   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82285   jresult = (int)result;
82286   return jresult;
82287 }
82288
82289
82290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82291   int jresult ;
82292   int result;
82293
82294   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82295   jresult = (int)result;
82296   return jresult;
82297 }
82298
82299
82300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82301   int jresult ;
82302   int result;
82303
82304   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82305   jresult = (int)result;
82306   return jresult;
82307 }
82308
82309
82310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82311   int jresult ;
82312   int result;
82313
82314   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82315   jresult = (int)result;
82316   return jresult;
82317 }
82318
82319
82320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82321   int jresult ;
82322   int result;
82323
82324   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82325   jresult = (int)result;
82326   return jresult;
82327 }
82328
82329
82330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82331   int jresult ;
82332   int result;
82333
82334   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82335   jresult = (int)result;
82336   return jresult;
82337 }
82338
82339
82340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82341   int jresult ;
82342   int result;
82343
82344   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82345   jresult = (int)result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82351   int jresult ;
82352   int result;
82353
82354   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82355   jresult = (int)result;
82356   return jresult;
82357 }
82358
82359
82360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82361   int jresult ;
82362   int result;
82363
82364   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82365   jresult = (int)result;
82366   return jresult;
82367 }
82368
82369
82370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82371   void * jresult ;
82372   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82373
82374   {
82375     try {
82376       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82377     } catch (std::out_of_range& e) {
82378       {
82379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82380       };
82381     } catch (std::exception& e) {
82382       {
82383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82384       };
82385     } catch (...) {
82386       {
82387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82388       };
82389     }
82390   }
82391   jresult = (void *)result;
82392   return jresult;
82393 }
82394
82395
82396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82397   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82398
82399   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82400   {
82401     try {
82402       delete arg1;
82403     } catch (std::out_of_range& e) {
82404       {
82405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82406       };
82407     } catch (std::exception& e) {
82408       {
82409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82410       };
82411     } catch (...) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82414       };
82415     }
82416   }
82417 }
82418
82419
82420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82421   void * jresult ;
82422   Dali::Toolkit::ProgressBar result;
82423
82424   {
82425     try {
82426       result = Dali::Toolkit::ProgressBar::New();
82427     } catch (std::out_of_range& e) {
82428       {
82429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82430       };
82431     } catch (std::exception& e) {
82432       {
82433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82434       };
82435     } catch (...) {
82436       {
82437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82438       };
82439     }
82440   }
82441   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82442   return jresult;
82443 }
82444
82445
82446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82447   void * jresult ;
82448   Dali::Toolkit::ProgressBar *result = 0 ;
82449
82450   {
82451     try {
82452       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82453     } catch (std::out_of_range& e) {
82454       {
82455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82456       };
82457     } catch (std::exception& e) {
82458       {
82459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82460       };
82461     } catch (...) {
82462       {
82463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82464       };
82465     }
82466   }
82467   jresult = (void *)result;
82468   return jresult;
82469 }
82470
82471
82472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82473   void * jresult ;
82474   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82475   Dali::Toolkit::ProgressBar *result = 0 ;
82476
82477   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82478   if (!arg1) {
82479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82480     return 0;
82481   }
82482   {
82483     try {
82484       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82485     } catch (std::out_of_range& e) {
82486       {
82487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82488       };
82489     } catch (std::exception& e) {
82490       {
82491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82492       };
82493     } catch (...) {
82494       {
82495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82496       };
82497     }
82498   }
82499   jresult = (void *)result;
82500   return jresult;
82501 }
82502
82503
82504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82505   void * jresult ;
82506   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82507   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82508   Dali::Toolkit::ProgressBar *result = 0 ;
82509
82510   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82511   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82512   if (!arg2) {
82513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82514     return 0;
82515   }
82516   {
82517     try {
82518       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82519     } catch (std::out_of_range& e) {
82520       {
82521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82522       };
82523     } catch (std::exception& e) {
82524       {
82525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82526       };
82527     } catch (...) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82530       };
82531     }
82532   }
82533   jresult = (void *)result;
82534   return jresult;
82535 }
82536
82537
82538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82539   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82540
82541   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82542   {
82543     try {
82544       delete arg1;
82545     } catch (std::out_of_range& e) {
82546       {
82547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82548       };
82549     } catch (std::exception& e) {
82550       {
82551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82552       };
82553     } catch (...) {
82554       {
82555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82556       };
82557     }
82558   }
82559 }
82560
82561
82562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82563   void * jresult ;
82564   Dali::BaseHandle arg1 ;
82565   Dali::BaseHandle *argp1 ;
82566   Dali::Toolkit::ProgressBar result;
82567
82568   argp1 = (Dali::BaseHandle *)jarg1;
82569   if (!argp1) {
82570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82571     return 0;
82572   }
82573   arg1 = *argp1;
82574   {
82575     try {
82576       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82577     } catch (std::out_of_range& e) {
82578       {
82579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82580       };
82581     } catch (std::exception& e) {
82582       {
82583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (...) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82588       };
82589     }
82590   }
82591   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82592   return jresult;
82593 }
82594
82595
82596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82597   void * jresult ;
82598   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82599   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82600
82601   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82602   {
82603     try {
82604       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82605     } catch (std::out_of_range& e) {
82606       {
82607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82608       };
82609     } catch (std::exception& e) {
82610       {
82611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82612       };
82613     } catch (...) {
82614       {
82615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82616       };
82617     }
82618   }
82619   jresult = (void *)result;
82620   return jresult;
82621 }
82622
82623
82624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82625   void * jresult ;
82626   Dali::Toolkit::GaussianBlurView *result = 0 ;
82627
82628   {
82629     try {
82630       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82631     } catch (std::out_of_range& e) {
82632       {
82633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (std::exception& e) {
82636       {
82637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82638       };
82639     } catch (...) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82642       };
82643     }
82644   }
82645   jresult = (void *)result;
82646   return jresult;
82647 }
82648
82649
82650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82651   void * jresult ;
82652   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82653   Dali::Toolkit::GaussianBlurView *result = 0 ;
82654
82655   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82656   if (!arg1) {
82657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82658     return 0;
82659   }
82660   {
82661     try {
82662       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82663     } catch (std::out_of_range& e) {
82664       {
82665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82666       };
82667     } catch (std::exception& e) {
82668       {
82669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82670       };
82671     } catch (...) {
82672       {
82673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82674       };
82675     }
82676   }
82677   jresult = (void *)result;
82678   return jresult;
82679 }
82680
82681
82682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82683   void * jresult ;
82684   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82685   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82686   Dali::Toolkit::GaussianBlurView *result = 0 ;
82687
82688   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82689   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82690   if (!arg2) {
82691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82692     return 0;
82693   }
82694   {
82695     try {
82696       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82697     } catch (std::out_of_range& e) {
82698       {
82699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (std::exception& e) {
82702       {
82703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82704       };
82705     } catch (...) {
82706       {
82707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82708       };
82709     }
82710   }
82711   jresult = (void *)result;
82712   return jresult;
82713 }
82714
82715
82716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82717   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82718
82719   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82720   {
82721     try {
82722       delete arg1;
82723     } catch (std::out_of_range& e) {
82724       {
82725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82726       };
82727     } catch (std::exception& e) {
82728       {
82729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82734       };
82735     }
82736   }
82737 }
82738
82739
82740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82741   void * jresult ;
82742   Dali::BaseHandle arg1 ;
82743   Dali::BaseHandle *argp1 ;
82744   Dali::Toolkit::GaussianBlurView result;
82745
82746   argp1 = (Dali::BaseHandle *)jarg1;
82747   if (!argp1) {
82748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82749     return 0;
82750   }
82751   arg1 = *argp1;
82752   {
82753     try {
82754       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82755     } catch (std::out_of_range& e) {
82756       {
82757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82758       };
82759     } catch (std::exception& e) {
82760       {
82761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82762       };
82763     } catch (...) {
82764       {
82765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82766       };
82767     }
82768   }
82769   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82775   void * jresult ;
82776   Dali::Toolkit::GaussianBlurView result;
82777
82778   {
82779     try {
82780       result = Dali::Toolkit::GaussianBlurView::New();
82781     } catch (std::out_of_range& e) {
82782       {
82783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82784       };
82785     } catch (std::exception& e) {
82786       {
82787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82788       };
82789     } catch (...) {
82790       {
82791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82792       };
82793     }
82794   }
82795   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82796   return jresult;
82797 }
82798
82799
82800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82801   void * jresult ;
82802   unsigned int arg1 ;
82803   float arg2 ;
82804   Dali::Pixel::Format arg3 ;
82805   float arg4 ;
82806   float arg5 ;
82807   bool arg6 ;
82808   Dali::Toolkit::GaussianBlurView result;
82809
82810   arg1 = (unsigned int)jarg1;
82811   arg2 = (float)jarg2;
82812   arg3 = (Dali::Pixel::Format)jarg3;
82813   arg4 = (float)jarg4;
82814   arg5 = (float)jarg5;
82815   arg6 = jarg6 ? true : false;
82816   {
82817     try {
82818       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82819     } catch (std::out_of_range& e) {
82820       {
82821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82822       };
82823     } catch (std::exception& e) {
82824       {
82825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82826       };
82827     } catch (...) {
82828       {
82829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82830       };
82831     }
82832   }
82833   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82834   return jresult;
82835 }
82836
82837
82838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82839   void * jresult ;
82840   unsigned int arg1 ;
82841   float arg2 ;
82842   Dali::Pixel::Format arg3 ;
82843   float arg4 ;
82844   float arg5 ;
82845   Dali::Toolkit::GaussianBlurView result;
82846
82847   arg1 = (unsigned int)jarg1;
82848   arg2 = (float)jarg2;
82849   arg3 = (Dali::Pixel::Format)jarg3;
82850   arg4 = (float)jarg4;
82851   arg5 = (float)jarg5;
82852   {
82853     try {
82854       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82855     } catch (std::out_of_range& e) {
82856       {
82857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (std::exception& e) {
82860       {
82861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82862       };
82863     } catch (...) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82866       };
82867     }
82868   }
82869   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82875   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82876   Dali::Actor arg2 ;
82877   Dali::Actor *argp2 ;
82878
82879   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82880   argp2 = (Dali::Actor *)jarg2;
82881   if (!argp2) {
82882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82883     return ;
82884   }
82885   arg2 = *argp2;
82886   {
82887     try {
82888       (arg1)->Add(arg2);
82889     } catch (std::out_of_range& e) {
82890       {
82891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82892       };
82893     } catch (std::exception& e) {
82894       {
82895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82896       };
82897     } catch (...) {
82898       {
82899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82900       };
82901     }
82902   }
82903 }
82904
82905
82906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82907   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82908   Dali::Actor arg2 ;
82909   Dali::Actor *argp2 ;
82910
82911   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82912   argp2 = (Dali::Actor *)jarg2;
82913   if (!argp2) {
82914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82915     return ;
82916   }
82917   arg2 = *argp2;
82918   {
82919     try {
82920       (arg1)->Remove(arg2);
82921     } catch (std::out_of_range& e) {
82922       {
82923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82924       };
82925     } catch (std::exception& e) {
82926       {
82927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82928       };
82929     } catch (...) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82932       };
82933     }
82934   }
82935 }
82936
82937
82938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82939   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82940
82941   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82942   {
82943     try {
82944       (arg1)->Activate();
82945     } catch (std::out_of_range& e) {
82946       {
82947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82948       };
82949     } catch (std::exception& e) {
82950       {
82951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82952       };
82953     } catch (...) {
82954       {
82955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82956       };
82957     }
82958   }
82959 }
82960
82961
82962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82963   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82964
82965   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82966   {
82967     try {
82968       (arg1)->ActivateOnce();
82969     } catch (std::out_of_range& e) {
82970       {
82971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82972       };
82973     } catch (std::exception& e) {
82974       {
82975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82976       };
82977     } catch (...) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82980       };
82981     }
82982   }
82983 }
82984
82985
82986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82987   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82988
82989   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82990   {
82991     try {
82992       (arg1)->Deactivate();
82993     } catch (std::out_of_range& e) {
82994       {
82995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82996       };
82997     } catch (std::exception& e) {
82998       {
82999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83000       };
83001     } catch (...) {
83002       {
83003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83004       };
83005     }
83006   }
83007 }
83008
83009
83010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83011   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83012   Dali::Image arg2 ;
83013   Dali::FrameBufferImage arg3 ;
83014   Dali::Image *argp2 ;
83015   Dali::FrameBufferImage *argp3 ;
83016
83017   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83018   argp2 = (Dali::Image *)jarg2;
83019   if (!argp2) {
83020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83021     return ;
83022   }
83023   arg2 = *argp2;
83024   argp3 = (Dali::FrameBufferImage *)jarg3;
83025   if (!argp3) {
83026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83027     return ;
83028   }
83029   arg3 = *argp3;
83030   {
83031     try {
83032       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83033     } catch (std::out_of_range& e) {
83034       {
83035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83036       };
83037     } catch (std::exception& e) {
83038       {
83039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (...) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83044       };
83045     }
83046   }
83047 }
83048
83049
83050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83051   int jresult ;
83052   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83053   Dali::Property::Index result;
83054
83055   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83056   {
83057     try {
83058       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83059     } catch (std::out_of_range& e) {
83060       {
83061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (std::exception& e) {
83064       {
83065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83066       };
83067     } catch (...) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83070       };
83071     }
83072   }
83073   jresult = result;
83074   return jresult;
83075 }
83076
83077
83078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83079   void * jresult ;
83080   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83081   Dali::FrameBufferImage result;
83082
83083   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83084   {
83085     try {
83086       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (...) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83098       };
83099     }
83100   }
83101   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83102   return jresult;
83103 }
83104
83105
83106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83107   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83108   Dali::Vector4 *arg2 = 0 ;
83109
83110   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83111   arg2 = (Dali::Vector4 *)jarg2;
83112   if (!arg2) {
83113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83114     return ;
83115   }
83116   {
83117     try {
83118       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83119     } catch (std::out_of_range& e) {
83120       {
83121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83122       };
83123     } catch (std::exception& e) {
83124       {
83125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83126       };
83127     } catch (...) {
83128       {
83129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83130       };
83131     }
83132   }
83133 }
83134
83135
83136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83137   void * jresult ;
83138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83139   Dali::Vector4 result;
83140
83141   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83142   {
83143     try {
83144       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83145     } catch (std::out_of_range& e) {
83146       {
83147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83148       };
83149     } catch (std::exception& e) {
83150       {
83151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83152       };
83153     } catch (...) {
83154       {
83155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83156       };
83157     }
83158   }
83159   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83160   return jresult;
83161 }
83162
83163
83164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83165   void * jresult ;
83166   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83167   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83168
83169   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83170   {
83171     try {
83172       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83173     } catch (std::out_of_range& e) {
83174       {
83175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83176       };
83177     } catch (std::exception& e) {
83178       {
83179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83184       };
83185     }
83186   }
83187   jresult = (void *)result;
83188   return jresult;
83189 }
83190
83191
83192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83193   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83194
83195   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83196   {
83197     try {
83198       delete arg1;
83199     } catch (std::out_of_range& e) {
83200       {
83201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (std::exception& e) {
83204       {
83205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83206       };
83207     } catch (...) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83210       };
83211     }
83212   }
83213 }
83214
83215
83216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83217   unsigned int jresult ;
83218   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83219   unsigned int result;
83220
83221   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83222   {
83223     try {
83224       result = (unsigned int)(arg1)->GetNumberOfPages();
83225     } catch (std::out_of_range& e) {
83226       {
83227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (std::exception& e) {
83230       {
83231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83232       };
83233     } catch (...) {
83234       {
83235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83236       };
83237     }
83238   }
83239   jresult = result;
83240   return jresult;
83241 }
83242
83243
83244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83245   void * jresult ;
83246   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83247   unsigned int arg2 ;
83248   Dali::Texture result;
83249
83250   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83251   arg2 = (unsigned int)jarg2;
83252   {
83253     try {
83254       result = (arg1)->NewPage(arg2);
83255     } catch (std::out_of_range& e) {
83256       {
83257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83258       };
83259     } catch (std::exception& e) {
83260       {
83261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83266       };
83267     }
83268   }
83269   jresult = new Dali::Texture((const Dali::Texture &)result);
83270   return jresult;
83271 }
83272
83273
83274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83275   int jresult ;
83276   int result;
83277
83278   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83279   jresult = (int)result;
83280   return jresult;
83281 }
83282
83283
83284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83285   int jresult ;
83286   int result;
83287
83288   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83289   jresult = (int)result;
83290   return jresult;
83291 }
83292
83293
83294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83295   int jresult ;
83296   int result;
83297
83298   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83299   jresult = (int)result;
83300   return jresult;
83301 }
83302
83303
83304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83305   void * jresult ;
83306   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83307
83308   {
83309     try {
83310       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83311     } catch (std::out_of_range& e) {
83312       {
83313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83314       };
83315     } catch (std::exception& e) {
83316       {
83317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83318       };
83319     } catch (...) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83322       };
83323     }
83324   }
83325   jresult = (void *)result;
83326   return jresult;
83327 }
83328
83329
83330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83331   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83332
83333   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83334   {
83335     try {
83336       delete arg1;
83337     } catch (std::out_of_range& e) {
83338       {
83339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83340       };
83341     } catch (std::exception& e) {
83342       {
83343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83348       };
83349     }
83350   }
83351 }
83352
83353
83354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83355   void * jresult ;
83356   Dali::Toolkit::PageTurnView *result = 0 ;
83357
83358   {
83359     try {
83360       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83361     } catch (std::out_of_range& e) {
83362       {
83363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (std::exception& e) {
83366       {
83367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83368       };
83369     } catch (...) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83372       };
83373     }
83374   }
83375   jresult = (void *)result;
83376   return jresult;
83377 }
83378
83379
83380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83381   void * jresult ;
83382   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83383   Dali::Toolkit::PageTurnView *result = 0 ;
83384
83385   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83386   if (!arg1) {
83387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83388     return 0;
83389   }
83390   {
83391     try {
83392       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83393     } catch (std::out_of_range& e) {
83394       {
83395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83396       };
83397     } catch (std::exception& e) {
83398       {
83399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83400       };
83401     } catch (...) {
83402       {
83403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83404       };
83405     }
83406   }
83407   jresult = (void *)result;
83408   return jresult;
83409 }
83410
83411
83412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83413   void * jresult ;
83414   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83415   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83416   Dali::Toolkit::PageTurnView *result = 0 ;
83417
83418   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83419   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83420   if (!arg2) {
83421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83422     return 0;
83423   }
83424   {
83425     try {
83426       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83427     } catch (std::out_of_range& e) {
83428       {
83429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83430       };
83431     } catch (std::exception& e) {
83432       {
83433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83434       };
83435     } catch (...) {
83436       {
83437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83438       };
83439     }
83440   }
83441   jresult = (void *)result;
83442   return jresult;
83443 }
83444
83445
83446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83447   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83448
83449   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83450   {
83451     try {
83452       delete arg1;
83453     } catch (std::out_of_range& e) {
83454       {
83455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83456       };
83457     } catch (std::exception& e) {
83458       {
83459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83460       };
83461     } catch (...) {
83462       {
83463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83464       };
83465     }
83466   }
83467 }
83468
83469
83470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83471   void * jresult ;
83472   Dali::BaseHandle arg1 ;
83473   Dali::BaseHandle *argp1 ;
83474   Dali::Toolkit::PageTurnView result;
83475
83476   argp1 = (Dali::BaseHandle *)jarg1;
83477   if (!argp1) {
83478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83479     return 0;
83480   }
83481   arg1 = *argp1;
83482   {
83483     try {
83484       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83485     } catch (std::out_of_range& e) {
83486       {
83487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83488       };
83489     } catch (std::exception& e) {
83490       {
83491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (...) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83496       };
83497     }
83498   }
83499   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83500   return jresult;
83501 }
83502
83503
83504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83505   void * jresult ;
83506   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83507   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83508
83509   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83510   {
83511     try {
83512       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83513     } catch (std::out_of_range& e) {
83514       {
83515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (std::exception& e) {
83518       {
83519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83520       };
83521     } catch (...) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83524       };
83525     }
83526   }
83527   jresult = (void *)result;
83528   return jresult;
83529 }
83530
83531
83532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83533   void * jresult ;
83534   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83535   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83536
83537   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83538   {
83539     try {
83540       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83541     } catch (std::out_of_range& e) {
83542       {
83543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83544       };
83545     } catch (std::exception& e) {
83546       {
83547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83548       };
83549     } catch (...) {
83550       {
83551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83552       };
83553     }
83554   }
83555   jresult = (void *)result;
83556   return jresult;
83557 }
83558
83559
83560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83561   void * jresult ;
83562   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83563   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83564
83565   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83566   {
83567     try {
83568       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83576       };
83577     } catch (...) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83580       };
83581     }
83582   }
83583   jresult = (void *)result;
83584   return jresult;
83585 }
83586
83587
83588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83589   void * jresult ;
83590   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83591   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83592
83593   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83594   {
83595     try {
83596       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83597     } catch (std::out_of_range& e) {
83598       {
83599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83600       };
83601     } catch (std::exception& e) {
83602       {
83603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83604       };
83605     } catch (...) {
83606       {
83607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83608       };
83609     }
83610   }
83611   jresult = (void *)result;
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83617   void * jresult ;
83618   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83619
83620   {
83621     try {
83622       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83623     } catch (std::out_of_range& e) {
83624       {
83625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83626       };
83627     } catch (std::exception& e) {
83628       {
83629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83630       };
83631     } catch (...) {
83632       {
83633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83634       };
83635     }
83636   }
83637   jresult = (void *)result;
83638   return jresult;
83639 }
83640
83641
83642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83643   void * jresult ;
83644   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83645   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83646
83647   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83648   if (!arg1) {
83649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83650     return 0;
83651   }
83652   {
83653     try {
83654       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83655     } catch (std::out_of_range& e) {
83656       {
83657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83658       };
83659     } catch (std::exception& e) {
83660       {
83661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83662       };
83663     } catch (...) {
83664       {
83665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83666       };
83667     }
83668   }
83669   jresult = (void *)result;
83670   return jresult;
83671 }
83672
83673
83674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83675   void * jresult ;
83676   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83677   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83678   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83679
83680   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83681   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83682   if (!arg2) {
83683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83684     return 0;
83685   }
83686   {
83687     try {
83688       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83689     } catch (std::out_of_range& e) {
83690       {
83691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83692       };
83693     } catch (std::exception& e) {
83694       {
83695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83696       };
83697     } catch (...) {
83698       {
83699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83700       };
83701     }
83702   }
83703   jresult = (void *)result;
83704   return jresult;
83705 }
83706
83707
83708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83709   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83710
83711   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83712   {
83713     try {
83714       delete arg1;
83715     } catch (std::out_of_range& e) {
83716       {
83717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83718       };
83719     } catch (std::exception& e) {
83720       {
83721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83722       };
83723     } catch (...) {
83724       {
83725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83726       };
83727     }
83728   }
83729 }
83730
83731
83732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83733   void * jresult ;
83734   Dali::Toolkit::PageFactory *arg1 = 0 ;
83735   Dali::Vector2 *arg2 = 0 ;
83736   Dali::Toolkit::PageTurnLandscapeView result;
83737
83738   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83739   if (!arg1) {
83740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83741     return 0;
83742   }
83743   arg2 = (Dali::Vector2 *)jarg2;
83744   if (!arg2) {
83745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83746     return 0;
83747   }
83748   {
83749     try {
83750       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83751     } catch (std::out_of_range& e) {
83752       {
83753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83754       };
83755     } catch (std::exception& e) {
83756       {
83757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83758       };
83759     } catch (...) {
83760       {
83761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83762       };
83763     }
83764   }
83765   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83766   return jresult;
83767 }
83768
83769
83770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83771   void * jresult ;
83772   Dali::BaseHandle arg1 ;
83773   Dali::BaseHandle *argp1 ;
83774   Dali::Toolkit::PageTurnLandscapeView result;
83775
83776   argp1 = (Dali::BaseHandle *)jarg1;
83777   if (!argp1) {
83778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83779     return 0;
83780   }
83781   arg1 = *argp1;
83782   {
83783     try {
83784       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83785     } catch (std::out_of_range& e) {
83786       {
83787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83788       };
83789     } catch (std::exception& e) {
83790       {
83791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83792       };
83793     } catch (...) {
83794       {
83795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83796       };
83797     }
83798   }
83799   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83800   return jresult;
83801 }
83802
83803
83804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83805   void * jresult ;
83806   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83807
83808   {
83809     try {
83810       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83811     } catch (std::out_of_range& e) {
83812       {
83813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83814       };
83815     } catch (std::exception& e) {
83816       {
83817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83818       };
83819     } catch (...) {
83820       {
83821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83822       };
83823     }
83824   }
83825   jresult = (void *)result;
83826   return jresult;
83827 }
83828
83829
83830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83831   void * jresult ;
83832   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83833   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83834
83835   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83836   if (!arg1) {
83837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83838     return 0;
83839   }
83840   {
83841     try {
83842       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83843     } catch (std::out_of_range& e) {
83844       {
83845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (std::exception& e) {
83848       {
83849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83850       };
83851     } catch (...) {
83852       {
83853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83854       };
83855     }
83856   }
83857   jresult = (void *)result;
83858   return jresult;
83859 }
83860
83861
83862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83863   void * jresult ;
83864   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83865   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83866   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83867
83868   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83869   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83870   if (!arg2) {
83871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83872     return 0;
83873   }
83874   {
83875     try {
83876       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83877     } catch (std::out_of_range& e) {
83878       {
83879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83880       };
83881     } catch (std::exception& e) {
83882       {
83883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83884       };
83885     } catch (...) {
83886       {
83887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83888       };
83889     }
83890   }
83891   jresult = (void *)result;
83892   return jresult;
83893 }
83894
83895
83896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83897   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83898
83899   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83900   {
83901     try {
83902       delete arg1;
83903     } catch (std::out_of_range& e) {
83904       {
83905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83906       };
83907     } catch (std::exception& e) {
83908       {
83909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83910       };
83911     } catch (...) {
83912       {
83913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83914       };
83915     }
83916   }
83917 }
83918
83919
83920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83921   void * jresult ;
83922   Dali::Toolkit::PageFactory *arg1 = 0 ;
83923   Dali::Vector2 *arg2 = 0 ;
83924   Dali::Toolkit::PageTurnPortraitView result;
83925
83926   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83927   if (!arg1) {
83928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83929     return 0;
83930   }
83931   arg2 = (Dali::Vector2 *)jarg2;
83932   if (!arg2) {
83933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83934     return 0;
83935   }
83936   {
83937     try {
83938       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83939     } catch (std::out_of_range& e) {
83940       {
83941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83942       };
83943     } catch (std::exception& e) {
83944       {
83945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83946       };
83947     } catch (...) {
83948       {
83949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83950       };
83951     }
83952   }
83953   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83954   return jresult;
83955 }
83956
83957
83958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83959   void * jresult ;
83960   Dali::BaseHandle arg1 ;
83961   Dali::BaseHandle *argp1 ;
83962   Dali::Toolkit::PageTurnPortraitView result;
83963
83964   argp1 = (Dali::BaseHandle *)jarg1;
83965   if (!argp1) {
83966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83967     return 0;
83968   }
83969   arg1 = *argp1;
83970   {
83971     try {
83972       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83973     } catch (std::out_of_range& e) {
83974       {
83975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83976       };
83977     } catch (std::exception& e) {
83978       {
83979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83980       };
83981     } catch (...) {
83982       {
83983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83984       };
83985     }
83986   }
83987   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83988   return jresult;
83989 }
83990
83991
83992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83993   int jresult ;
83994   int result;
83995
83996   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83997   jresult = (int)result;
83998   return jresult;
83999 }
84000
84001
84002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84003   int jresult ;
84004   int result;
84005
84006   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84007   jresult = (int)result;
84008   return jresult;
84009 }
84010
84011
84012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84013   int jresult ;
84014   int result;
84015
84016   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84017   jresult = (int)result;
84018   return jresult;
84019 }
84020
84021
84022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84023   void * jresult ;
84024   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84025
84026   {
84027     try {
84028       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84029     } catch (std::out_of_range& e) {
84030       {
84031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84032       };
84033     } catch (std::exception& e) {
84034       {
84035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (...) {
84038       {
84039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84040       };
84041     }
84042   }
84043   jresult = (void *)result;
84044   return jresult;
84045 }
84046
84047
84048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84049   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84050
84051   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84052   {
84053     try {
84054       delete arg1;
84055     } catch (std::out_of_range& e) {
84056       {
84057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (std::exception& e) {
84060       {
84061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069 }
84070
84071
84072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84073   void * jresult ;
84074   Dali::Toolkit::ToggleButton *result = 0 ;
84075
84076   {
84077     try {
84078       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84086       };
84087     } catch (...) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84090       };
84091     }
84092   }
84093   jresult = (void *)result;
84094   return jresult;
84095 }
84096
84097
84098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84099   void * jresult ;
84100   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84101   Dali::Toolkit::ToggleButton *result = 0 ;
84102
84103   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84104   if (!arg1) {
84105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84106     return 0;
84107   }
84108   {
84109     try {
84110       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84111     } catch (std::out_of_range& e) {
84112       {
84113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84114       };
84115     } catch (std::exception& e) {
84116       {
84117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84118       };
84119     } catch (...) {
84120       {
84121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84122       };
84123     }
84124   }
84125   jresult = (void *)result;
84126   return jresult;
84127 }
84128
84129
84130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84131   void * jresult ;
84132   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84133   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84134   Dali::Toolkit::ToggleButton *result = 0 ;
84135
84136   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84137   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84138   if (!arg2) {
84139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84140     return 0;
84141   }
84142   {
84143     try {
84144       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84145     } catch (std::out_of_range& e) {
84146       {
84147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84148       };
84149     } catch (std::exception& e) {
84150       {
84151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84152       };
84153     } catch (...) {
84154       {
84155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84156       };
84157     }
84158   }
84159   jresult = (void *)result;
84160   return jresult;
84161 }
84162
84163
84164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84165   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84166
84167   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84168   {
84169     try {
84170       delete arg1;
84171     } catch (std::out_of_range& e) {
84172       {
84173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84174       };
84175     } catch (std::exception& e) {
84176       {
84177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84178       };
84179     } catch (...) {
84180       {
84181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84182       };
84183     }
84184   }
84185 }
84186
84187
84188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84189   void * jresult ;
84190   Dali::Toolkit::ToggleButton result;
84191
84192   {
84193     try {
84194       result = Dali::Toolkit::ToggleButton::New();
84195     } catch (std::out_of_range& e) {
84196       {
84197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84198       };
84199     } catch (std::exception& e) {
84200       {
84201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84202       };
84203     } catch (...) {
84204       {
84205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84206       };
84207     }
84208   }
84209   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84210   return jresult;
84211 }
84212
84213
84214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84215   void * jresult ;
84216   Dali::BaseHandle arg1 ;
84217   Dali::BaseHandle *argp1 ;
84218   Dali::Toolkit::ToggleButton result;
84219
84220   argp1 = (Dali::BaseHandle *)jarg1;
84221   if (!argp1) {
84222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84223     return 0;
84224   }
84225   arg1 = *argp1;
84226   {
84227     try {
84228       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84240       };
84241     }
84242   }
84243   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84244   return jresult;
84245 }
84246
84247
84248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84249   void * jresult ;
84250   Dali::Toolkit::Visual::Base *result = 0 ;
84251
84252   {
84253     try {
84254       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84255     } catch (std::out_of_range& e) {
84256       {
84257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84258       };
84259     } catch (std::exception& e) {
84260       {
84261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84262       };
84263     } catch (...) {
84264       {
84265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84266       };
84267     }
84268   }
84269   jresult = (void *)result;
84270   return jresult;
84271 }
84272
84273
84274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84275   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84276
84277   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84278   {
84279     try {
84280       delete arg1;
84281     } catch (std::out_of_range& e) {
84282       {
84283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84284       };
84285     } catch (std::exception& e) {
84286       {
84287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84288       };
84289     } catch (...) {
84290       {
84291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84292       };
84293     }
84294   }
84295 }
84296
84297
84298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84299   void * jresult ;
84300   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84301   Dali::Toolkit::Visual::Base *result = 0 ;
84302
84303   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84304   if (!arg1) {
84305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84306     return 0;
84307   }
84308   {
84309     try {
84310       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84311     } catch (std::out_of_range& e) {
84312       {
84313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84314       };
84315     } catch (std::exception& e) {
84316       {
84317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84318       };
84319     } catch (...) {
84320       {
84321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84322       };
84323     }
84324   }
84325   jresult = (void *)result;
84326   return jresult;
84327 }
84328
84329
84330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84331   void * jresult ;
84332   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84333   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84334   Dali::Toolkit::Visual::Base *result = 0 ;
84335
84336   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84337   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84338   if (!arg2) {
84339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84340     return 0;
84341   }
84342   {
84343     try {
84344       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (...) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84356       };
84357     }
84358   }
84359   jresult = (void *)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84365   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84366   std::string *arg2 = 0 ;
84367
84368   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84369   if (!jarg2) {
84370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84371     return ;
84372   }
84373   std::string arg2_str(jarg2);
84374   arg2 = &arg2_str;
84375   {
84376     try {
84377       (arg1)->SetName((std::string const &)*arg2);
84378     } catch (std::out_of_range& e) {
84379       {
84380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84381       };
84382     } catch (std::exception& e) {
84383       {
84384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84385       };
84386     } catch (...) {
84387       {
84388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84389       };
84390     }
84391   }
84392
84393   //argout typemap for const std::string&
84394
84395 }
84396
84397
84398 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84399   char * jresult ;
84400   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84401   std::string *result = 0 ;
84402
84403   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84404   {
84405     try {
84406       result = (std::string *) &(arg1)->GetName();
84407     } catch (std::out_of_range& e) {
84408       {
84409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84410       };
84411     } catch (std::exception& e) {
84412       {
84413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (...) {
84416       {
84417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84418       };
84419     }
84420   }
84421   jresult = SWIG_csharp_string_callback(result->c_str());
84422   return jresult;
84423 }
84424
84425
84426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84427   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84428   Dali::Property::Map *arg2 = 0 ;
84429   Dali::Size arg3 ;
84430   Dali::Size *argp3 ;
84431
84432   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84433   arg2 = (Dali::Property::Map *)jarg2;
84434   if (!arg2) {
84435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84436     return ;
84437   }
84438   argp3 = (Dali::Size *)jarg3;
84439   if (!argp3) {
84440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84441     return ;
84442   }
84443   arg3 = *argp3;
84444   {
84445     try {
84446       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84447     } catch (std::out_of_range& e) {
84448       {
84449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84450       };
84451     } catch (std::exception& e) {
84452       {
84453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84454       };
84455     } catch (...) {
84456       {
84457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84458       };
84459     }
84460   }
84461 }
84462
84463
84464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84465   float jresult ;
84466   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84467   float arg2 ;
84468   float result;
84469
84470   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84471   arg2 = (float)jarg2;
84472   {
84473     try {
84474       result = (float)(arg1)->GetHeightForWidth(arg2);
84475     } catch (std::out_of_range& e) {
84476       {
84477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (std::exception& e) {
84480       {
84481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (...) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84486       };
84487     }
84488   }
84489   jresult = result;
84490   return jresult;
84491 }
84492
84493
84494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84495   float jresult ;
84496   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84497   float arg2 ;
84498   float result;
84499
84500   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84501   arg2 = (float)jarg2;
84502   {
84503     try {
84504       result = (float)(arg1)->GetWidthForHeight(arg2);
84505     } catch (std::out_of_range& e) {
84506       {
84507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (std::exception& e) {
84510       {
84511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84512       };
84513     } catch (...) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84516       };
84517     }
84518   }
84519   jresult = result;
84520   return jresult;
84521 }
84522
84523
84524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84525   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84526   Dali::Vector2 *arg2 = 0 ;
84527
84528   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84529   arg2 = (Dali::Vector2 *)jarg2;
84530   if (!arg2) {
84531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84532     return ;
84533   }
84534   {
84535     try {
84536       (arg1)->GetNaturalSize(*arg2);
84537     } catch (std::out_of_range& e) {
84538       {
84539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84540       };
84541     } catch (std::exception& e) {
84542       {
84543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84544       };
84545     } catch (...) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84548       };
84549     }
84550   }
84551 }
84552
84553
84554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84555   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84556   float arg2 ;
84557
84558   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84559   arg2 = (float)jarg2;
84560   {
84561     try {
84562       (arg1)->SetDepthIndex(arg2);
84563     } catch (std::out_of_range& e) {
84564       {
84565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84566       };
84567     } catch (std::exception& e) {
84568       {
84569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84574       };
84575     }
84576   }
84577 }
84578
84579
84580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84581   float jresult ;
84582   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84583   float result;
84584
84585   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84586   {
84587     try {
84588       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84589     } catch (std::out_of_range& e) {
84590       {
84591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84592       };
84593     } catch (std::exception& e) {
84594       {
84595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84596       };
84597     } catch (...) {
84598       {
84599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84600       };
84601     }
84602   }
84603   jresult = result;
84604   return jresult;
84605 }
84606
84607
84608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84609   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84610   Dali::Property::Map *arg2 = 0 ;
84611
84612   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84613   arg2 = (Dali::Property::Map *)jarg2;
84614   if (!arg2) {
84615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84616     return ;
84617   }
84618   {
84619     try {
84620       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84621     } catch (std::out_of_range& e) {
84622       {
84623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84624       };
84625     } catch (std::exception& e) {
84626       {
84627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84628       };
84629     } catch (...) {
84630       {
84631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84632       };
84633     }
84634   }
84635 }
84636
84637
84638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84639   void * jresult ;
84640   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84641   Dali::Toolkit::Visual::Base *result = 0 ;
84642
84643   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84644   {
84645     try {
84646       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84647     } catch (std::out_of_range& e) {
84648       {
84649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84650       };
84651     } catch (std::exception& e) {
84652       {
84653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84654       };
84655     } catch (...) {
84656       {
84657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84658       };
84659     }
84660   }
84661   jresult = (void *)result;
84662   return jresult;
84663 }
84664
84665
84666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84667   void * jresult ;
84668   Dali::Toolkit::VisualFactory result;
84669
84670   {
84671     try {
84672       result = Dali::Toolkit::VisualFactory::Get();
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (...) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84684       };
84685     }
84686   }
84687   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84688   return jresult;
84689 }
84690
84691
84692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84693   void * jresult ;
84694   Dali::Toolkit::VisualFactory *result = 0 ;
84695
84696   {
84697     try {
84698       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84699     } catch (std::out_of_range& e) {
84700       {
84701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (std::exception& e) {
84704       {
84705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (...) {
84708       {
84709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84710       };
84711     }
84712   }
84713   jresult = (void *)result;
84714   return jresult;
84715 }
84716
84717
84718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84719   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84720
84721   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84722   {
84723     try {
84724       delete arg1;
84725     } catch (std::out_of_range& e) {
84726       {
84727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84728       };
84729     } catch (std::exception& e) {
84730       {
84731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84732       };
84733     } catch (...) {
84734       {
84735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84736       };
84737     }
84738   }
84739 }
84740
84741
84742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84743   void * jresult ;
84744   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84745   Dali::Toolkit::VisualFactory *result = 0 ;
84746
84747   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84748   if (!arg1) {
84749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84750     return 0;
84751   }
84752   {
84753     try {
84754       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84755     } catch (std::out_of_range& e) {
84756       {
84757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (std::exception& e) {
84760       {
84761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84762       };
84763     } catch (...) {
84764       {
84765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84766       };
84767     }
84768   }
84769   jresult = (void *)result;
84770   return jresult;
84771 }
84772
84773
84774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84775   void * jresult ;
84776   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84777   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84778   Dali::Toolkit::VisualFactory *result = 0 ;
84779
84780   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84781   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84782   if (!arg2) {
84783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84784     return 0;
84785   }
84786   {
84787     try {
84788       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84789     } catch (std::out_of_range& e) {
84790       {
84791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84792       };
84793     } catch (std::exception& e) {
84794       {
84795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84800       };
84801     }
84802   }
84803   jresult = (void *)result;
84804   return jresult;
84805 }
84806
84807
84808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84809   void * jresult ;
84810   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84811   Dali::Property::Map *arg2 = 0 ;
84812   Dali::Toolkit::Visual::Base result;
84813
84814   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84815   arg2 = (Dali::Property::Map *)jarg2;
84816   if (!arg2) {
84817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84818     return 0;
84819   }
84820   {
84821     try {
84822       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84823     } catch (std::out_of_range& e) {
84824       {
84825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84826       };
84827     } catch (std::exception& e) {
84828       {
84829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84830       };
84831     } catch (...) {
84832       {
84833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84834       };
84835     }
84836   }
84837   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84838   return jresult;
84839 }
84840
84841
84842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84843   void * jresult ;
84844   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84845   Dali::Image *arg2 = 0 ;
84846   Dali::Toolkit::Visual::Base result;
84847
84848   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84849   arg2 = (Dali::Image *)jarg2;
84850   if (!arg2) {
84851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84852     return 0;
84853   }
84854   {
84855     try {
84856       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84857     } catch (std::out_of_range& e) {
84858       {
84859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (std::exception& e) {
84862       {
84863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84877   void * jresult ;
84878   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84879   std::string *arg2 = 0 ;
84880   Dali::ImageDimensions arg3 ;
84881   Dali::ImageDimensions *argp3 ;
84882   Dali::Toolkit::Visual::Base result;
84883
84884   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84885   if (!jarg2) {
84886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84887     return 0;
84888   }
84889   std::string arg2_str(jarg2);
84890   arg2 = &arg2_str;
84891   argp3 = (Dali::ImageDimensions *)jarg3;
84892   if (!argp3) {
84893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84894     return 0;
84895   }
84896   arg3 = *argp3;
84897   {
84898     try {
84899       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84900     } catch (std::out_of_range& e) {
84901       {
84902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84903       };
84904     } catch (std::exception& e) {
84905       {
84906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84907       };
84908     } catch (...) {
84909       {
84910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84911       };
84912     }
84913   }
84914   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84915
84916   //argout typemap for const std::string&
84917
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84923   void * jresult ;
84924   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84925
84926   {
84927     try {
84928       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84929     } catch (std::out_of_range& e) {
84930       {
84931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84932       };
84933     } catch (std::exception& e) {
84934       {
84935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84936       };
84937     } catch (...) {
84938       {
84939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84940       };
84941     }
84942   }
84943   jresult = (void *)result;
84944   return jresult;
84945 }
84946
84947
84948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84949   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84950
84951   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84952   {
84953     try {
84954       delete arg1;
84955     } catch (std::out_of_range& e) {
84956       {
84957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84958       };
84959     } catch (std::exception& e) {
84960       {
84961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84962       };
84963     } catch (...) {
84964       {
84965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84966       };
84967     }
84968   }
84969 }
84970
84971
84972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84973   void * jresult ;
84974   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84975   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84976
84977   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84978   if (!arg1) {
84979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84980     return 0;
84981   }
84982   {
84983     try {
84984       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84985     } catch (std::out_of_range& e) {
84986       {
84987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84988       };
84989     } catch (std::exception& e) {
84990       {
84991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84992       };
84993     } catch (...) {
84994       {
84995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84996       };
84997     }
84998   }
84999   jresult = (void *)result;
85000   return jresult;
85001 }
85002
85003
85004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85005   void * jresult ;
85006   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85007   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85008   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85009
85010   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85011   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85012   if (!arg2) {
85013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85014     return 0;
85015   }
85016   {
85017     try {
85018       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85019     } catch (std::out_of_range& e) {
85020       {
85021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85022       };
85023     } catch (std::exception& e) {
85024       {
85025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (...) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85030       };
85031     }
85032   }
85033   jresult = (void *)result;
85034   return jresult;
85035 }
85036
85037
85038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85039   void * jresult ;
85040   Dali::Toolkit::AsyncImageLoader result;
85041
85042   {
85043     try {
85044       result = Dali::Toolkit::AsyncImageLoader::New();
85045     } catch (std::out_of_range& e) {
85046       {
85047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85048       };
85049     } catch (std::exception& e) {
85050       {
85051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85052       };
85053     } catch (...) {
85054       {
85055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85056       };
85057     }
85058   }
85059   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85060   return jresult;
85061 }
85062
85063
85064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85065   void * jresult ;
85066   Dali::BaseHandle arg1 ;
85067   Dali::BaseHandle *argp1 ;
85068   Dali::Toolkit::AsyncImageLoader result;
85069
85070   argp1 = (Dali::BaseHandle *)jarg1;
85071   if (!argp1) {
85072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85073     return 0;
85074   }
85075   arg1 = *argp1;
85076   {
85077     try {
85078       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85090       };
85091     }
85092   }
85093   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85094   return jresult;
85095 }
85096
85097
85098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85099   unsigned int jresult ;
85100   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85101   std::string *arg2 = 0 ;
85102   uint32_t result;
85103
85104   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85105   if (!jarg2) {
85106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85107     return 0;
85108   }
85109   std::string arg2_str(jarg2);
85110   arg2 = &arg2_str;
85111   {
85112     try {
85113       result = (arg1)->Load((std::string const &)*arg2);
85114     } catch (std::out_of_range& e) {
85115       {
85116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85117       };
85118     } catch (std::exception& e) {
85119       {
85120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (...) {
85123       {
85124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85125       };
85126     }
85127   }
85128   jresult = result;
85129
85130   //argout typemap for const std::string&
85131
85132   return jresult;
85133 }
85134
85135
85136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85137   unsigned int jresult ;
85138   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85139   std::string *arg2 = 0 ;
85140   Dali::ImageDimensions arg3 ;
85141   Dali::ImageDimensions *argp3 ;
85142   uint32_t result;
85143
85144   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85145   if (!jarg2) {
85146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85147     return 0;
85148   }
85149   std::string arg2_str(jarg2);
85150   arg2 = &arg2_str;
85151   argp3 = (Dali::ImageDimensions *)jarg3;
85152   if (!argp3) {
85153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85154     return 0;
85155   }
85156   arg3 = *argp3;
85157   {
85158     try {
85159       result = (arg1)->Load((std::string const &)*arg2,arg3);
85160     } catch (std::out_of_range& e) {
85161       {
85162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (std::exception& e) {
85165       {
85166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85167       };
85168     } catch (...) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85171       };
85172     }
85173   }
85174   jresult = result;
85175
85176   //argout typemap for const std::string&
85177
85178   return jresult;
85179 }
85180
85181
85182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85183   unsigned int jresult ;
85184   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85185   std::string *arg2 = 0 ;
85186   Dali::ImageDimensions arg3 ;
85187   Dali::FittingMode::Type arg4 ;
85188   Dali::SamplingMode::Type arg5 ;
85189   bool arg6 ;
85190   Dali::ImageDimensions *argp3 ;
85191   uint32_t result;
85192
85193   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85194   if (!jarg2) {
85195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85196     return 0;
85197   }
85198   std::string arg2_str(jarg2);
85199   arg2 = &arg2_str;
85200   argp3 = (Dali::ImageDimensions *)jarg3;
85201   if (!argp3) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85203     return 0;
85204   }
85205   arg3 = *argp3;
85206   arg4 = (Dali::FittingMode::Type)jarg4;
85207   arg5 = (Dali::SamplingMode::Type)jarg5;
85208   arg6 = jarg6 ? true : false;
85209   {
85210     try {
85211       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85212     } catch (std::out_of_range& e) {
85213       {
85214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85215       };
85216     } catch (std::exception& e) {
85217       {
85218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85219       };
85220     } catch (...) {
85221       {
85222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85223       };
85224     }
85225   }
85226   jresult = result;
85227
85228   //argout typemap for const std::string&
85229
85230   return jresult;
85231 }
85232
85233
85234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85235   unsigned int jresult ;
85236   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85237   uint32_t arg2 ;
85238   bool result;
85239
85240   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85241   arg2 = (uint32_t)jarg2;
85242   {
85243     try {
85244       result = (bool)(arg1)->Cancel(arg2);
85245     } catch (std::out_of_range& e) {
85246       {
85247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85248       };
85249     } catch (std::exception& e) {
85250       {
85251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85252       };
85253     } catch (...) {
85254       {
85255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85256       };
85257     }
85258   }
85259   jresult = result;
85260   return jresult;
85261 }
85262
85263
85264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85265   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85266
85267   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85268   {
85269     try {
85270       (arg1)->CancelAll();
85271     } catch (std::out_of_range& e) {
85272       {
85273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85274       };
85275     } catch (std::exception& e) {
85276       {
85277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85278       };
85279     } catch (...) {
85280       {
85281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85282       };
85283     }
85284   }
85285 }
85286
85287
85288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85289   void * jresult ;
85290   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85291   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85292
85293   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85294   {
85295     try {
85296       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85297     } catch (std::out_of_range& e) {
85298       {
85299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (std::exception& e) {
85302       {
85303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85304       };
85305     } catch (...) {
85306       {
85307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85308       };
85309     }
85310   }
85311   jresult = (void *)result;
85312   return jresult;
85313 }
85314
85315
85316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85317   void * jresult ;
85318   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85319   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85320
85321   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85322   {
85323     try {
85324       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85325     } catch (std::out_of_range& e) {
85326       {
85327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85328       };
85329     } catch (std::exception& e) {
85330       {
85331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (...) {
85334       {
85335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85336       };
85337     }
85338   }
85339   jresult = (void *)result;
85340   return jresult;
85341 }
85342
85343
85344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85345   void * jresult ;
85346   std::string *arg1 = 0 ;
85347   Dali::PixelData result;
85348
85349   if (!jarg1) {
85350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85351     return 0;
85352   }
85353   std::string arg1_str(jarg1);
85354   arg1 = &arg1_str;
85355   {
85356     try {
85357       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85358     } catch (std::out_of_range& e) {
85359       {
85360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85361       };
85362     } catch (std::exception& e) {
85363       {
85364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85365       };
85366     } catch (...) {
85367       {
85368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85369       };
85370     }
85371   }
85372   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85373
85374   //argout typemap for const std::string&
85375
85376   return jresult;
85377 }
85378
85379
85380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85381   void * jresult ;
85382   std::string *arg1 = 0 ;
85383   Dali::ImageDimensions arg2 ;
85384   Dali::ImageDimensions *argp2 ;
85385   Dali::PixelData result;
85386
85387   if (!jarg1) {
85388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85389     return 0;
85390   }
85391   std::string arg1_str(jarg1);
85392   arg1 = &arg1_str;
85393   argp2 = (Dali::ImageDimensions *)jarg2;
85394   if (!argp2) {
85395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85396     return 0;
85397   }
85398   arg2 = *argp2;
85399   {
85400     try {
85401       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85402     } catch (std::out_of_range& e) {
85403       {
85404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85405       };
85406     } catch (std::exception& e) {
85407       {
85408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (...) {
85411       {
85412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85413       };
85414     }
85415   }
85416   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85417
85418   //argout typemap for const std::string&
85419
85420   return jresult;
85421 }
85422
85423
85424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85425   void * jresult ;
85426   std::string *arg1 = 0 ;
85427   Dali::ImageDimensions arg2 ;
85428   Dali::FittingMode::Type arg3 ;
85429   Dali::SamplingMode::Type arg4 ;
85430   bool arg5 ;
85431   Dali::ImageDimensions *argp2 ;
85432   Dali::PixelData result;
85433
85434   if (!jarg1) {
85435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85436     return 0;
85437   }
85438   std::string arg1_str(jarg1);
85439   arg1 = &arg1_str;
85440   argp2 = (Dali::ImageDimensions *)jarg2;
85441   if (!argp2) {
85442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85443     return 0;
85444   }
85445   arg2 = *argp2;
85446   arg3 = (Dali::FittingMode::Type)jarg3;
85447   arg4 = (Dali::SamplingMode::Type)jarg4;
85448   arg5 = jarg5 ? true : false;
85449   {
85450     try {
85451       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (...) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85463       };
85464     }
85465   }
85466   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85467
85468   //argout typemap for const std::string&
85469
85470   return jresult;
85471 }
85472
85473
85474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85475   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85476
85477   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85478   {
85479     try {
85480       delete arg1;
85481     } catch (std::out_of_range& e) {
85482       {
85483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85484       };
85485     } catch (std::exception& e) {
85486       {
85487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85488       };
85489     } catch (...) {
85490       {
85491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85492       };
85493     }
85494   }
85495 }
85496
85497
85498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85499   void * jresult ;
85500   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85501   Dali::Actor arg2 ;
85502   Dali::Actor arg3 ;
85503   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85504   Dali::Actor *argp2 ;
85505   Dali::Actor *argp3 ;
85506   Dali::Actor result;
85507
85508   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85509   argp2 = (Dali::Actor *)jarg2;
85510   if (!argp2) {
85511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85512     return 0;
85513   }
85514   arg2 = *argp2;
85515   argp3 = (Dali::Actor *)jarg3;
85516   if (!argp3) {
85517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85518     return 0;
85519   }
85520   arg3 = *argp3;
85521   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85522   {
85523     try {
85524       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85525     } catch (std::out_of_range& e) {
85526       {
85527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85528       };
85529     } catch (std::exception& e) {
85530       {
85531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85532       };
85533     } catch (...) {
85534       {
85535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85536       };
85537     }
85538   }
85539   jresult = new Dali::Actor((const Dali::Actor &)result);
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85545   void * jresult ;
85546   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85547
85548   {
85549     try {
85550       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85558       };
85559     } catch (...) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85562       };
85563     }
85564   }
85565   jresult = (void *)result;
85566   return jresult;
85567 }
85568
85569
85570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85571   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85572   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85573   if (director) {
85574     director->swig_connect_director(callback0);
85575   }
85576 }
85577
85578
85579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85580   KeyboardFocusManager arg1 ;
85581   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85582   KeyboardFocusManager *argp1 ;
85583
85584   argp1 = (KeyboardFocusManager *)jarg1;
85585   if (!argp1) {
85586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85587     return ;
85588   }
85589   arg1 = *argp1;
85590   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85591   if (!arg2) {
85592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85593     return ;
85594   }
85595   {
85596     try {
85597       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85598     } catch (std::out_of_range& e) {
85599       {
85600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85601       };
85602     } catch (std::exception& e) {
85603       {
85604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85605       };
85606     } catch (...) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85609       };
85610     }
85611   }
85612 }
85613
85614
85615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85616   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85617
85618   arg1 = (std::vector< unsigned int > *)jarg1;
85619   {
85620     try {
85621       (arg1)->clear();
85622     } catch (std::out_of_range& e) {
85623       {
85624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85625       };
85626     } catch (std::exception& e) {
85627       {
85628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85629       };
85630     } catch (...) {
85631       {
85632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85633       };
85634     }
85635   }
85636 }
85637
85638
85639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85640   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85641   unsigned int *arg2 = 0 ;
85642   unsigned int temp2 ;
85643
85644   arg1 = (std::vector< unsigned int > *)jarg1;
85645   temp2 = (unsigned int)jarg2;
85646   arg2 = &temp2;
85647   {
85648     try {
85649       (arg1)->push_back((unsigned int const &)*arg2);
85650     } catch (std::out_of_range& e) {
85651       {
85652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85653       };
85654     } catch (std::exception& e) {
85655       {
85656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85657       };
85658     } catch (...) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85661       };
85662     }
85663   }
85664 }
85665
85666
85667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85668   unsigned long jresult ;
85669   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85670   std::vector< unsigned int >::size_type result;
85671
85672   arg1 = (std::vector< unsigned int > *)jarg1;
85673   {
85674     try {
85675       result = ((std::vector< unsigned int > const *)arg1)->size();
85676     } catch (std::out_of_range& e) {
85677       {
85678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (std::exception& e) {
85681       {
85682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85683       };
85684     } catch (...) {
85685       {
85686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85687       };
85688     }
85689   }
85690   jresult = (unsigned long)result;
85691   return jresult;
85692 }
85693
85694
85695 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85696   unsigned long jresult ;
85697   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85698   std::vector< unsigned int >::size_type result;
85699
85700   arg1 = (std::vector< unsigned int > *)jarg1;
85701   {
85702     try {
85703       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85704     } catch (std::out_of_range& e) {
85705       {
85706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85707       };
85708     } catch (std::exception& e) {
85709       {
85710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85711       };
85712     } catch (...) {
85713       {
85714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85715       };
85716     }
85717   }
85718   jresult = (unsigned long)result;
85719   return jresult;
85720 }
85721
85722
85723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85724   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85725   std::vector< unsigned int >::size_type arg2 ;
85726
85727   arg1 = (std::vector< unsigned int > *)jarg1;
85728   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85729   {
85730     try {
85731       (arg1)->reserve(arg2);
85732     } catch (std::out_of_range& e) {
85733       {
85734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85735       };
85736     } catch (std::exception& e) {
85737       {
85738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85739       };
85740     } catch (...) {
85741       {
85742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85743       };
85744     }
85745   }
85746 }
85747
85748
85749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85750   void * jresult ;
85751   std::vector< unsigned int > *result = 0 ;
85752
85753   {
85754     try {
85755       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (...) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85767       };
85768     }
85769   }
85770   jresult = (void *)result;
85771   return jresult;
85772 }
85773
85774
85775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85776   void * jresult ;
85777   std::vector< unsigned int > *arg1 = 0 ;
85778   std::vector< unsigned int > *result = 0 ;
85779
85780   arg1 = (std::vector< unsigned int > *)jarg1;
85781   if (!arg1) {
85782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85783     return 0;
85784   }
85785   {
85786     try {
85787       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85788     } catch (std::out_of_range& e) {
85789       {
85790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (std::exception& e) {
85793       {
85794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802   jresult = (void *)result;
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85808   void * jresult ;
85809   int arg1 ;
85810   std::vector< unsigned int > *result = 0 ;
85811
85812   arg1 = (int)jarg1;
85813   {
85814     try {
85815       try {
85816         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85817       }
85818       catch(std::out_of_range &_e) {
85819         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85820         return 0;
85821       }
85822
85823     } catch (std::out_of_range& e) {
85824       {
85825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85826       };
85827     } catch (std::exception& e) {
85828       {
85829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85830       };
85831     } catch (...) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85834       };
85835     }
85836   }
85837   jresult = (void *)result;
85838   return jresult;
85839 }
85840
85841
85842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85843   unsigned int jresult ;
85844   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85845   int arg2 ;
85846   unsigned int result;
85847
85848   arg1 = (std::vector< unsigned int > *)jarg1;
85849   arg2 = (int)jarg2;
85850   {
85851     try {
85852       try {
85853         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85854       }
85855       catch(std::out_of_range &_e) {
85856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85857         return 0;
85858       }
85859
85860     } catch (std::out_of_range& e) {
85861       {
85862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85863       };
85864     } catch (std::exception& e) {
85865       {
85866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85867       };
85868     } catch (...) {
85869       {
85870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85871       };
85872     }
85873   }
85874   jresult = result;
85875   return jresult;
85876 }
85877
85878
85879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85880   unsigned int jresult ;
85881   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85882   int arg2 ;
85883   unsigned int *result = 0 ;
85884
85885   arg1 = (std::vector< unsigned int > *)jarg1;
85886   arg2 = (int)jarg2;
85887   {
85888     try {
85889       try {
85890         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85891       }
85892       catch(std::out_of_range &_e) {
85893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85894         return 0;
85895       }
85896
85897     } catch (std::out_of_range& e) {
85898       {
85899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85900       };
85901     } catch (std::exception& e) {
85902       {
85903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (...) {
85906       {
85907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85908       };
85909     }
85910   }
85911   jresult = *result;
85912   return jresult;
85913 }
85914
85915
85916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85917   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85918   int arg2 ;
85919   unsigned int *arg3 = 0 ;
85920   unsigned int temp3 ;
85921
85922   arg1 = (std::vector< unsigned int > *)jarg1;
85923   arg2 = (int)jarg2;
85924   temp3 = (unsigned int)jarg3;
85925   arg3 = &temp3;
85926   {
85927     try {
85928       try {
85929         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85930       }
85931       catch(std::out_of_range &_e) {
85932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85933         return ;
85934       }
85935
85936     } catch (std::out_of_range& e) {
85937       {
85938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85939       };
85940     } catch (std::exception& e) {
85941       {
85942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85943       };
85944     } catch (...) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85947       };
85948     }
85949   }
85950 }
85951
85952
85953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85954   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85955   std::vector< unsigned int > *arg2 = 0 ;
85956
85957   arg1 = (std::vector< unsigned int > *)jarg1;
85958   arg2 = (std::vector< unsigned int > *)jarg2;
85959   if (!arg2) {
85960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85961     return ;
85962   }
85963   {
85964     try {
85965       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85973       };
85974     } catch (...) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85977       };
85978     }
85979   }
85980 }
85981
85982
85983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85984   void * jresult ;
85985   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85986   int arg2 ;
85987   int arg3 ;
85988   std::vector< unsigned int > *result = 0 ;
85989
85990   arg1 = (std::vector< unsigned int > *)jarg1;
85991   arg2 = (int)jarg2;
85992   arg3 = (int)jarg3;
85993   {
85994     try {
85995       try {
85996         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85997       }
85998       catch(std::out_of_range &_e) {
85999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86000         return 0;
86001       }
86002       catch(std::invalid_argument &_e) {
86003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86004         return 0;
86005       }
86006
86007     } catch (std::out_of_range& e) {
86008       {
86009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86010       };
86011     } catch (std::exception& e) {
86012       {
86013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86014       };
86015     } catch (...) {
86016       {
86017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86018       };
86019     }
86020   }
86021   jresult = (void *)result;
86022   return jresult;
86023 }
86024
86025
86026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86027   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86028   int arg2 ;
86029   unsigned int *arg3 = 0 ;
86030   unsigned int temp3 ;
86031
86032   arg1 = (std::vector< unsigned int > *)jarg1;
86033   arg2 = (int)jarg2;
86034   temp3 = (unsigned int)jarg3;
86035   arg3 = &temp3;
86036   {
86037     try {
86038       try {
86039         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86040       }
86041       catch(std::out_of_range &_e) {
86042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86043         return ;
86044       }
86045
86046     } catch (std::out_of_range& e) {
86047       {
86048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86049       };
86050     } catch (std::exception& e) {
86051       {
86052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86053       };
86054     } catch (...) {
86055       {
86056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86057       };
86058     }
86059   }
86060 }
86061
86062
86063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86064   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86065   int arg2 ;
86066   std::vector< unsigned int > *arg3 = 0 ;
86067
86068   arg1 = (std::vector< unsigned int > *)jarg1;
86069   arg2 = (int)jarg2;
86070   arg3 = (std::vector< unsigned int > *)jarg3;
86071   if (!arg3) {
86072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86073     return ;
86074   }
86075   {
86076     try {
86077       try {
86078         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86079       }
86080       catch(std::out_of_range &_e) {
86081         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86082         return ;
86083       }
86084
86085     } catch (std::out_of_range& e) {
86086       {
86087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86088       };
86089     } catch (std::exception& e) {
86090       {
86091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86092       };
86093     } catch (...) {
86094       {
86095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86096       };
86097     }
86098   }
86099 }
86100
86101
86102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86103   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86104   int arg2 ;
86105
86106   arg1 = (std::vector< unsigned int > *)jarg1;
86107   arg2 = (int)jarg2;
86108   {
86109     try {
86110       try {
86111         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86112       }
86113       catch(std::out_of_range &_e) {
86114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86115         return ;
86116       }
86117
86118     } catch (std::out_of_range& e) {
86119       {
86120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86121       };
86122     } catch (std::exception& e) {
86123       {
86124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86125       };
86126     } catch (...) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86129       };
86130     }
86131   }
86132 }
86133
86134
86135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86137   int arg2 ;
86138   int arg3 ;
86139
86140   arg1 = (std::vector< unsigned int > *)jarg1;
86141   arg2 = (int)jarg2;
86142   arg3 = (int)jarg3;
86143   {
86144     try {
86145       try {
86146         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86147       }
86148       catch(std::out_of_range &_e) {
86149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86150         return ;
86151       }
86152       catch(std::invalid_argument &_e) {
86153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86154         return ;
86155       }
86156
86157     } catch (std::out_of_range& e) {
86158       {
86159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86160       };
86161     } catch (std::exception& e) {
86162       {
86163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86164       };
86165     } catch (...) {
86166       {
86167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86168       };
86169     }
86170   }
86171 }
86172
86173
86174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86175   void * jresult ;
86176   unsigned int *arg1 = 0 ;
86177   int arg2 ;
86178   unsigned int temp1 ;
86179   std::vector< unsigned int > *result = 0 ;
86180
86181   temp1 = (unsigned int)jarg1;
86182   arg1 = &temp1;
86183   arg2 = (int)jarg2;
86184   {
86185     try {
86186       try {
86187         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86188       }
86189       catch(std::out_of_range &_e) {
86190         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86191         return 0;
86192       }
86193
86194     } catch (std::out_of_range& e) {
86195       {
86196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86197       };
86198     } catch (std::exception& e) {
86199       {
86200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (...) {
86203       {
86204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86205       };
86206     }
86207   }
86208   jresult = (void *)result;
86209   return jresult;
86210 }
86211
86212
86213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86214   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86215
86216   arg1 = (std::vector< unsigned int > *)jarg1;
86217   {
86218     try {
86219       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86220     } catch (std::out_of_range& e) {
86221       {
86222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86223       };
86224     } catch (std::exception& e) {
86225       {
86226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86227       };
86228     } catch (...) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86231       };
86232     }
86233   }
86234 }
86235
86236
86237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86238   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86239   int arg2 ;
86240   int arg3 ;
86241
86242   arg1 = (std::vector< unsigned int > *)jarg1;
86243   arg2 = (int)jarg2;
86244   arg3 = (int)jarg3;
86245   {
86246     try {
86247       try {
86248         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86249       }
86250       catch(std::out_of_range &_e) {
86251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86252         return ;
86253       }
86254       catch(std::invalid_argument &_e) {
86255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86256         return ;
86257       }
86258
86259     } catch (std::out_of_range& e) {
86260       {
86261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86262       };
86263     } catch (std::exception& e) {
86264       {
86265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86266       };
86267     } catch (...) {
86268       {
86269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86270       };
86271     }
86272   }
86273 }
86274
86275
86276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86278   int arg2 ;
86279   std::vector< unsigned int > *arg3 = 0 ;
86280
86281   arg1 = (std::vector< unsigned int > *)jarg1;
86282   arg2 = (int)jarg2;
86283   arg3 = (std::vector< unsigned int > *)jarg3;
86284   if (!arg3) {
86285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86286     return ;
86287   }
86288   {
86289     try {
86290       try {
86291         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86292       }
86293       catch(std::out_of_range &_e) {
86294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86295         return ;
86296       }
86297
86298     } catch (std::out_of_range& e) {
86299       {
86300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86301       };
86302     } catch (std::exception& e) {
86303       {
86304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86305       };
86306     } catch (...) {
86307       {
86308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86309       };
86310     }
86311   }
86312 }
86313
86314
86315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86316   unsigned int jresult ;
86317   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86318   unsigned int *arg2 = 0 ;
86319   unsigned int temp2 ;
86320   bool result;
86321
86322   arg1 = (std::vector< unsigned int > *)jarg1;
86323   temp2 = (unsigned int)jarg2;
86324   arg2 = &temp2;
86325   {
86326     try {
86327       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86328     } catch (std::out_of_range& e) {
86329       {
86330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (std::exception& e) {
86333       {
86334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86335       };
86336     } catch (...) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86339       };
86340     }
86341   }
86342   jresult = result;
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86348   int jresult ;
86349   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86350   unsigned int *arg2 = 0 ;
86351   unsigned int temp2 ;
86352   int result;
86353
86354   arg1 = (std::vector< unsigned int > *)jarg1;
86355   temp2 = (unsigned int)jarg2;
86356   arg2 = &temp2;
86357   {
86358     try {
86359       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86360     } catch (std::out_of_range& e) {
86361       {
86362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86363       };
86364     } catch (std::exception& e) {
86365       {
86366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86367       };
86368     } catch (...) {
86369       {
86370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86371       };
86372     }
86373   }
86374   jresult = result;
86375   return jresult;
86376 }
86377
86378
86379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86380   int jresult ;
86381   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86382   unsigned int *arg2 = 0 ;
86383   unsigned int temp2 ;
86384   int result;
86385
86386   arg1 = (std::vector< unsigned int > *)jarg1;
86387   temp2 = (unsigned int)jarg2;
86388   arg2 = &temp2;
86389   {
86390     try {
86391       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86392     } catch (std::out_of_range& e) {
86393       {
86394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (std::exception& e) {
86397       {
86398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406   jresult = result;
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86412   unsigned int jresult ;
86413   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86414   unsigned int *arg2 = 0 ;
86415   unsigned int temp2 ;
86416   bool result;
86417
86418   arg1 = (std::vector< unsigned int > *)jarg1;
86419   temp2 = (unsigned int)jarg2;
86420   arg2 = &temp2;
86421   {
86422     try {
86423       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86424     } catch (std::out_of_range& e) {
86425       {
86426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86427       };
86428     } catch (std::exception& e) {
86429       {
86430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86435       };
86436     }
86437   }
86438   jresult = result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86444   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86445
86446   arg1 = (std::vector< unsigned int > *)jarg1;
86447   {
86448     try {
86449       delete arg1;
86450     } catch (std::out_of_range& e) {
86451       {
86452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86453       };
86454     } catch (std::exception& e) {
86455       {
86456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86457       };
86458     } catch (...) {
86459       {
86460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86461       };
86462     }
86463   }
86464 }
86465
86466
86467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86468   void * jresult ;
86469   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86470
86471   {
86472     try {
86473       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86474     } catch (std::out_of_range& e) {
86475       {
86476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86477       };
86478     } catch (std::exception& e) {
86479       {
86480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86485       };
86486     }
86487   }
86488   jresult = (void *)result;
86489   return jresult;
86490 }
86491
86492
86493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86494   void * jresult ;
86495   unsigned int arg1 ;
86496   Dali::Actor arg2 ;
86497   Dali::Actor *argp2 ;
86498   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86499
86500   arg1 = (unsigned int)jarg1;
86501   argp2 = (Dali::Actor *)jarg2;
86502   if (!argp2) {
86503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86504     return 0;
86505   }
86506   arg2 = *argp2;
86507   {
86508     try {
86509       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86510     } catch (std::out_of_range& e) {
86511       {
86512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86513       };
86514     } catch (std::exception& e) {
86515       {
86516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86517       };
86518     } catch (...) {
86519       {
86520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86521       };
86522     }
86523   }
86524   jresult = (void *)result;
86525   return jresult;
86526 }
86527
86528
86529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86530   void * jresult ;
86531   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86532   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86533
86534   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86535   if (!arg1) {
86536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86537     return 0;
86538   }
86539   {
86540     try {
86541       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86542     } catch (std::out_of_range& e) {
86543       {
86544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86545       };
86546     } catch (std::exception& e) {
86547       {
86548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86549       };
86550     } catch (...) {
86551       {
86552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86553       };
86554     }
86555   }
86556   jresult = (void *)result;
86557   return jresult;
86558 }
86559
86560
86561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86562   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86563   unsigned int arg2 ;
86564
86565   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86566   arg2 = (unsigned int)jarg2;
86567   if (arg1) (arg1)->first = arg2;
86568 }
86569
86570
86571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86572   unsigned int jresult ;
86573   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86574   unsigned int result;
86575
86576   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86577   result = (unsigned int) ((arg1)->first);
86578   jresult = result;
86579   return jresult;
86580 }
86581
86582
86583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86584   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86585   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86586
86587   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86588   arg2 = (Dali::Actor *)jarg2;
86589   if (arg1) (arg1)->second = *arg2;
86590 }
86591
86592
86593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86594   void * jresult ;
86595   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86596   Dali::Actor *result = 0 ;
86597
86598   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86599   result = (Dali::Actor *)& ((arg1)->second);
86600   jresult = (void *)result;
86601   return jresult;
86602 }
86603
86604
86605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86606   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86607
86608   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86609   {
86610     try {
86611       delete arg1;
86612     } catch (std::out_of_range& e) {
86613       {
86614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86615       };
86616     } catch (std::exception& e) {
86617       {
86618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86619       };
86620     } catch (...) {
86621       {
86622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86623       };
86624     }
86625   }
86626 }
86627
86628
86629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86630   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86631
86632   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86633   {
86634     try {
86635       (arg1)->clear();
86636     } catch (std::out_of_range& e) {
86637       {
86638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86639       };
86640     } catch (std::exception& e) {
86641       {
86642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86643       };
86644     } catch (...) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86647       };
86648     }
86649   }
86650 }
86651
86652
86653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86654   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86655   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86656
86657   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86658   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86659   if (!arg2) {
86660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86661     return ;
86662   }
86663   {
86664     try {
86665       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86677       };
86678     }
86679   }
86680 }
86681
86682
86683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86684   unsigned long jresult ;
86685   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86686   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86687
86688   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86689   {
86690     try {
86691       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86692     } catch (std::out_of_range& e) {
86693       {
86694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86695       };
86696     } catch (std::exception& e) {
86697       {
86698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86699       };
86700     } catch (...) {
86701       {
86702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86703       };
86704     }
86705   }
86706   jresult = (unsigned long)result;
86707   return jresult;
86708 }
86709
86710
86711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86712   unsigned long jresult ;
86713   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86714   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86715
86716   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86717   {
86718     try {
86719       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86720     } catch (std::out_of_range& e) {
86721       {
86722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86723       };
86724     } catch (std::exception& e) {
86725       {
86726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (...) {
86729       {
86730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86731       };
86732     }
86733   }
86734   jresult = (unsigned long)result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86740   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86741   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86742
86743   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86744   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86745   {
86746     try {
86747       (arg1)->reserve(arg2);
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86759       };
86760     }
86761   }
86762 }
86763
86764
86765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86766   void * jresult ;
86767   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86768
86769   {
86770     try {
86771       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86772     } catch (std::out_of_range& e) {
86773       {
86774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (std::exception& e) {
86777       {
86778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786   jresult = (void *)result;
86787   return jresult;
86788 }
86789
86790
86791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86792   void * jresult ;
86793   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86794   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86795
86796   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86797   if (!arg1) {
86798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86799     return 0;
86800   }
86801   {
86802     try {
86803       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);
86804     } catch (std::out_of_range& e) {
86805       {
86806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86807       };
86808     } catch (std::exception& e) {
86809       {
86810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86811       };
86812     } catch (...) {
86813       {
86814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86815       };
86816     }
86817   }
86818   jresult = (void *)result;
86819   return jresult;
86820 }
86821
86822
86823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86824   void * jresult ;
86825   int arg1 ;
86826   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86827
86828   arg1 = (int)jarg1;
86829   {
86830     try {
86831       try {
86832         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);
86833       }
86834       catch(std::out_of_range &_e) {
86835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86836         return 0;
86837       }
86838
86839     } catch (std::out_of_range& e) {
86840       {
86841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86842       };
86843     } catch (std::exception& e) {
86844       {
86845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86846       };
86847     } catch (...) {
86848       {
86849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86850       };
86851     }
86852   }
86853   jresult = (void *)result;
86854   return jresult;
86855 }
86856
86857
86858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86859   void * jresult ;
86860   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86861   int arg2 ;
86862   std::pair< unsigned int,Dali::Actor > result;
86863
86864   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86865   arg2 = (int)jarg2;
86866   {
86867     try {
86868       try {
86869         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86870       }
86871       catch(std::out_of_range &_e) {
86872         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86873         return 0;
86874       }
86875
86876     } catch (std::out_of_range& e) {
86877       {
86878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (std::exception& e) {
86881       {
86882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86887       };
86888     }
86889   }
86890   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86891   return jresult;
86892 }
86893
86894
86895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86896   void * jresult ;
86897   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86898   int arg2 ;
86899   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86900
86901   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86902   arg2 = (int)jarg2;
86903   {
86904     try {
86905       try {
86906         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86907       }
86908       catch(std::out_of_range &_e) {
86909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86910         return 0;
86911       }
86912
86913     } catch (std::out_of_range& e) {
86914       {
86915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86916       };
86917     } catch (std::exception& e) {
86918       {
86919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86920       };
86921     } catch (...) {
86922       {
86923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86924       };
86925     }
86926   }
86927   jresult = (void *)result;
86928   return jresult;
86929 }
86930
86931
86932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86933   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86934   int arg2 ;
86935   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86936
86937   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86938   arg2 = (int)jarg2;
86939   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86940   if (!arg3) {
86941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86942     return ;
86943   }
86944   {
86945     try {
86946       try {
86947         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);
86948       }
86949       catch(std::out_of_range &_e) {
86950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86951         return ;
86952       }
86953
86954     } catch (std::out_of_range& e) {
86955       {
86956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86957       };
86958     } catch (std::exception& e) {
86959       {
86960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86961       };
86962     } catch (...) {
86963       {
86964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86965       };
86966     }
86967   }
86968 }
86969
86970
86971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86973   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86974
86975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86976   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86977   if (!arg2) {
86978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86979     return ;
86980   }
86981   {
86982     try {
86983       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);
86984     } catch (std::out_of_range& e) {
86985       {
86986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86987       };
86988     } catch (std::exception& e) {
86989       {
86990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86991       };
86992     } catch (...) {
86993       {
86994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86995       };
86996     }
86997   }
86998 }
86999
87000
87001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87002   void * jresult ;
87003   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87004   int arg2 ;
87005   int arg3 ;
87006   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87007
87008   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87009   arg2 = (int)jarg2;
87010   arg3 = (int)jarg3;
87011   {
87012     try {
87013       try {
87014         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);
87015       }
87016       catch(std::out_of_range &_e) {
87017         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87018         return 0;
87019       }
87020       catch(std::invalid_argument &_e) {
87021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87022         return 0;
87023       }
87024
87025     } catch (std::out_of_range& e) {
87026       {
87027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87028       };
87029     } catch (std::exception& e) {
87030       {
87031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87032       };
87033     } catch (...) {
87034       {
87035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87036       };
87037     }
87038   }
87039   jresult = (void *)result;
87040   return jresult;
87041 }
87042
87043
87044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87045   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87046   int arg2 ;
87047   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87048
87049   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87050   arg2 = (int)jarg2;
87051   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87052   if (!arg3) {
87053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87054     return ;
87055   }
87056   {
87057     try {
87058       try {
87059         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);
87060       }
87061       catch(std::out_of_range &_e) {
87062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87063         return ;
87064       }
87065
87066     } catch (std::out_of_range& e) {
87067       {
87068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87069       };
87070     } catch (std::exception& e) {
87071       {
87072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87073       };
87074     } catch (...) {
87075       {
87076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87077       };
87078     }
87079   }
87080 }
87081
87082
87083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87085   int arg2 ;
87086   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87087
87088   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87089   arg2 = (int)jarg2;
87090   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87091   if (!arg3) {
87092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87093     return ;
87094   }
87095   {
87096     try {
87097       try {
87098         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);
87099       }
87100       catch(std::out_of_range &_e) {
87101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87102         return ;
87103       }
87104
87105     } catch (std::out_of_range& e) {
87106       {
87107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87108       };
87109     } catch (std::exception& e) {
87110       {
87111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87112       };
87113     } catch (...) {
87114       {
87115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87116       };
87117     }
87118   }
87119 }
87120
87121
87122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87123   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87124   int arg2 ;
87125
87126   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87127   arg2 = (int)jarg2;
87128   {
87129     try {
87130       try {
87131         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87132       }
87133       catch(std::out_of_range &_e) {
87134         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87135         return ;
87136       }
87137
87138     } catch (std::out_of_range& e) {
87139       {
87140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87141       };
87142     } catch (std::exception& e) {
87143       {
87144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87145       };
87146     } catch (...) {
87147       {
87148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87149       };
87150     }
87151   }
87152 }
87153
87154
87155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87156   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87157   int arg2 ;
87158   int arg3 ;
87159
87160   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87161   arg2 = (int)jarg2;
87162   arg3 = (int)jarg3;
87163   {
87164     try {
87165       try {
87166         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87167       }
87168       catch(std::out_of_range &_e) {
87169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87170         return ;
87171       }
87172       catch(std::invalid_argument &_e) {
87173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87174         return ;
87175       }
87176
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87184       };
87185     } catch (...) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87188       };
87189     }
87190   }
87191 }
87192
87193
87194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87195   void * jresult ;
87196   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87197   int arg2 ;
87198   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87199
87200   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87201   if (!arg1) {
87202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87203     return 0;
87204   }
87205   arg2 = (int)jarg2;
87206   {
87207     try {
87208       try {
87209         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);
87210       }
87211       catch(std::out_of_range &_e) {
87212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87213         return 0;
87214       }
87215
87216     } catch (std::out_of_range& e) {
87217       {
87218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87219       };
87220     } catch (std::exception& e) {
87221       {
87222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87223       };
87224     } catch (...) {
87225       {
87226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87227       };
87228     }
87229   }
87230   jresult = (void *)result;
87231   return jresult;
87232 }
87233
87234
87235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87236   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87237
87238   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87239   {
87240     try {
87241       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87242     } catch (std::out_of_range& e) {
87243       {
87244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87245       };
87246     } catch (std::exception& e) {
87247       {
87248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87249       };
87250     } catch (...) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87253       };
87254     }
87255   }
87256 }
87257
87258
87259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87260   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87261   int arg2 ;
87262   int arg3 ;
87263
87264   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87265   arg2 = (int)jarg2;
87266   arg3 = (int)jarg3;
87267   {
87268     try {
87269       try {
87270         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87271       }
87272       catch(std::out_of_range &_e) {
87273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87274         return ;
87275       }
87276       catch(std::invalid_argument &_e) {
87277         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87278         return ;
87279       }
87280
87281     } catch (std::out_of_range& e) {
87282       {
87283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87284       };
87285     } catch (std::exception& e) {
87286       {
87287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87288       };
87289     } catch (...) {
87290       {
87291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87292       };
87293     }
87294   }
87295 }
87296
87297
87298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87300   int arg2 ;
87301   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87302
87303   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87304   arg2 = (int)jarg2;
87305   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87306   if (!arg3) {
87307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87308     return ;
87309   }
87310   {
87311     try {
87312       try {
87313         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);
87314       }
87315       catch(std::out_of_range &_e) {
87316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87317         return ;
87318       }
87319
87320     } catch (std::out_of_range& e) {
87321       {
87322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87323       };
87324     } catch (std::exception& e) {
87325       {
87326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87327       };
87328     } catch (...) {
87329       {
87330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87331       };
87332     }
87333   }
87334 }
87335
87336
87337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87338   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87339
87340   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87341   {
87342     try {
87343       delete arg1;
87344     } catch (std::out_of_range& e) {
87345       {
87346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87347       };
87348     } catch (std::exception& e) {
87349       {
87350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87351       };
87352     } catch (...) {
87353       {
87354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87355       };
87356     }
87357   }
87358 }
87359
87360
87361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87362   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87363
87364   arg1 = (std::vector< Dali::Actor > *)jarg1;
87365   {
87366     try {
87367       (arg1)->clear();
87368     } catch (std::out_of_range& e) {
87369       {
87370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87371       };
87372     } catch (std::exception& e) {
87373       {
87374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87375       };
87376     } catch (...) {
87377       {
87378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87379       };
87380     }
87381   }
87382 }
87383
87384
87385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87386   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87387   Dali::Actor *arg2 = 0 ;
87388
87389   arg1 = (std::vector< Dali::Actor > *)jarg1;
87390   arg2 = (Dali::Actor *)jarg2;
87391   if (!arg2) {
87392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87393     return ;
87394   }
87395   {
87396     try {
87397       (arg1)->push_back((Dali::Actor const &)*arg2);
87398     } catch (std::out_of_range& e) {
87399       {
87400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87401       };
87402     } catch (std::exception& e) {
87403       {
87404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87405       };
87406     } catch (...) {
87407       {
87408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87409       };
87410     }
87411   }
87412 }
87413
87414
87415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87416   unsigned long jresult ;
87417   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87418   std::vector< Dali::Actor >::size_type result;
87419
87420   arg1 = (std::vector< Dali::Actor > *)jarg1;
87421   {
87422     try {
87423       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87424     } catch (std::out_of_range& e) {
87425       {
87426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87427       };
87428     } catch (std::exception& e) {
87429       {
87430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87431       };
87432     } catch (...) {
87433       {
87434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87435       };
87436     }
87437   }
87438   jresult = (unsigned long)result;
87439   return jresult;
87440 }
87441
87442
87443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87444   unsigned long jresult ;
87445   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87446   std::vector< Dali::Actor >::size_type result;
87447
87448   arg1 = (std::vector< Dali::Actor > *)jarg1;
87449   {
87450     try {
87451       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87452     } catch (std::out_of_range& e) {
87453       {
87454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87455       };
87456     } catch (std::exception& e) {
87457       {
87458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87459       };
87460     } catch (...) {
87461       {
87462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87463       };
87464     }
87465   }
87466   jresult = (unsigned long)result;
87467   return jresult;
87468 }
87469
87470
87471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87472   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87473   std::vector< Dali::Actor >::size_type arg2 ;
87474
87475   arg1 = (std::vector< Dali::Actor > *)jarg1;
87476   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87477   {
87478     try {
87479       (arg1)->reserve(arg2);
87480     } catch (std::out_of_range& e) {
87481       {
87482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87483       };
87484     } catch (std::exception& e) {
87485       {
87486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87487       };
87488     } catch (...) {
87489       {
87490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87491       };
87492     }
87493   }
87494 }
87495
87496
87497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87498   void * jresult ;
87499   std::vector< Dali::Actor > *result = 0 ;
87500
87501   {
87502     try {
87503       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87504     } catch (std::out_of_range& e) {
87505       {
87506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87507       };
87508     } catch (std::exception& e) {
87509       {
87510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87511       };
87512     } catch (...) {
87513       {
87514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87515       };
87516     }
87517   }
87518   jresult = (void *)result;
87519   return jresult;
87520 }
87521
87522
87523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87524   void * jresult ;
87525   std::vector< Dali::Actor > *arg1 = 0 ;
87526   std::vector< Dali::Actor > *result = 0 ;
87527
87528   arg1 = (std::vector< Dali::Actor > *)jarg1;
87529   if (!arg1) {
87530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87531     return 0;
87532   }
87533   {
87534     try {
87535       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87536     } catch (std::out_of_range& e) {
87537       {
87538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87539       };
87540     } catch (std::exception& e) {
87541       {
87542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87543       };
87544     } catch (...) {
87545       {
87546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87547       };
87548     }
87549   }
87550   jresult = (void *)result;
87551   return jresult;
87552 }
87553
87554
87555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87556   void * jresult ;
87557   int arg1 ;
87558   std::vector< Dali::Actor > *result = 0 ;
87559
87560   arg1 = (int)jarg1;
87561   {
87562     try {
87563       try {
87564         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87565       }
87566       catch(std::out_of_range &_e) {
87567         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87568         return 0;
87569       }
87570
87571     } catch (std::out_of_range& e) {
87572       {
87573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87574       };
87575     } catch (std::exception& e) {
87576       {
87577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87578       };
87579     } catch (...) {
87580       {
87581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87582       };
87583     }
87584   }
87585   jresult = (void *)result;
87586   return jresult;
87587 }
87588
87589
87590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87591   void * jresult ;
87592   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87593   int arg2 ;
87594   Dali::Actor result;
87595
87596   arg1 = (std::vector< Dali::Actor > *)jarg1;
87597   arg2 = (int)jarg2;
87598   {
87599     try {
87600       try {
87601         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87602       }
87603       catch(std::out_of_range &_e) {
87604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87605         return 0;
87606       }
87607
87608     } catch (std::out_of_range& e) {
87609       {
87610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87611       };
87612     } catch (std::exception& e) {
87613       {
87614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87615       };
87616     } catch (...) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87619       };
87620     }
87621   }
87622   jresult = new Dali::Actor((const Dali::Actor &)result);
87623   return jresult;
87624 }
87625
87626
87627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87628   void * jresult ;
87629   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87630   int arg2 ;
87631   Dali::Actor *result = 0 ;
87632
87633   arg1 = (std::vector< Dali::Actor > *)jarg1;
87634   arg2 = (int)jarg2;
87635   {
87636     try {
87637       try {
87638         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87639       }
87640       catch(std::out_of_range &_e) {
87641         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87642         return 0;
87643       }
87644
87645     } catch (std::out_of_range& e) {
87646       {
87647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87648       };
87649     } catch (std::exception& e) {
87650       {
87651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87652       };
87653     } catch (...) {
87654       {
87655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87656       };
87657     }
87658   }
87659   jresult = (void *)result;
87660   return jresult;
87661 }
87662
87663
87664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87665   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87666   int arg2 ;
87667   Dali::Actor *arg3 = 0 ;
87668
87669   arg1 = (std::vector< Dali::Actor > *)jarg1;
87670   arg2 = (int)jarg2;
87671   arg3 = (Dali::Actor *)jarg3;
87672   if (!arg3) {
87673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87674     return ;
87675   }
87676   {
87677     try {
87678       try {
87679         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87680       }
87681       catch(std::out_of_range &_e) {
87682         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87683         return ;
87684       }
87685
87686     } catch (std::out_of_range& e) {
87687       {
87688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (std::exception& e) {
87691       {
87692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87693       };
87694     } catch (...) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87697       };
87698     }
87699   }
87700 }
87701
87702
87703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87704   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87705   std::vector< Dali::Actor > *arg2 = 0 ;
87706
87707   arg1 = (std::vector< Dali::Actor > *)jarg1;
87708   arg2 = (std::vector< Dali::Actor > *)jarg2;
87709   if (!arg2) {
87710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87711     return ;
87712   }
87713   {
87714     try {
87715       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87716     } catch (std::out_of_range& e) {
87717       {
87718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87719       };
87720     } catch (std::exception& e) {
87721       {
87722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87723       };
87724     } catch (...) {
87725       {
87726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87727       };
87728     }
87729   }
87730 }
87731
87732
87733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87734   void * jresult ;
87735   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87736   int arg2 ;
87737   int arg3 ;
87738   std::vector< Dali::Actor > *result = 0 ;
87739
87740   arg1 = (std::vector< Dali::Actor > *)jarg1;
87741   arg2 = (int)jarg2;
87742   arg3 = (int)jarg3;
87743   {
87744     try {
87745       try {
87746         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87747       }
87748       catch(std::out_of_range &_e) {
87749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87750         return 0;
87751       }
87752       catch(std::invalid_argument &_e) {
87753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87754         return 0;
87755       }
87756
87757     } catch (std::out_of_range& e) {
87758       {
87759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87760       };
87761     } catch (std::exception& e) {
87762       {
87763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87764       };
87765     } catch (...) {
87766       {
87767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87768       };
87769     }
87770   }
87771   jresult = (void *)result;
87772   return jresult;
87773 }
87774
87775
87776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87777   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87778   int arg2 ;
87779   Dali::Actor *arg3 = 0 ;
87780
87781   arg1 = (std::vector< Dali::Actor > *)jarg1;
87782   arg2 = (int)jarg2;
87783   arg3 = (Dali::Actor *)jarg3;
87784   if (!arg3) {
87785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87786     return ;
87787   }
87788   {
87789     try {
87790       try {
87791         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87792       }
87793       catch(std::out_of_range &_e) {
87794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87795         return ;
87796       }
87797
87798     } catch (std::out_of_range& e) {
87799       {
87800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87801       };
87802     } catch (std::exception& e) {
87803       {
87804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87805       };
87806     } catch (...) {
87807       {
87808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87809       };
87810     }
87811   }
87812 }
87813
87814
87815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87816   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87817   int arg2 ;
87818   std::vector< Dali::Actor > *arg3 = 0 ;
87819
87820   arg1 = (std::vector< Dali::Actor > *)jarg1;
87821   arg2 = (int)jarg2;
87822   arg3 = (std::vector< Dali::Actor > *)jarg3;
87823   if (!arg3) {
87824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87825     return ;
87826   }
87827   {
87828     try {
87829       try {
87830         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87831       }
87832       catch(std::out_of_range &_e) {
87833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87834         return ;
87835       }
87836
87837     } catch (std::out_of_range& e) {
87838       {
87839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87840       };
87841     } catch (std::exception& e) {
87842       {
87843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87844       };
87845     } catch (...) {
87846       {
87847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87848       };
87849     }
87850   }
87851 }
87852
87853
87854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87855   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87856   int arg2 ;
87857
87858   arg1 = (std::vector< Dali::Actor > *)jarg1;
87859   arg2 = (int)jarg2;
87860   {
87861     try {
87862       try {
87863         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87864       }
87865       catch(std::out_of_range &_e) {
87866         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87867         return ;
87868       }
87869
87870     } catch (std::out_of_range& e) {
87871       {
87872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87873       };
87874     } catch (std::exception& e) {
87875       {
87876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87877       };
87878     } catch (...) {
87879       {
87880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87881       };
87882     }
87883   }
87884 }
87885
87886
87887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87888   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87889   int arg2 ;
87890   int arg3 ;
87891
87892   arg1 = (std::vector< Dali::Actor > *)jarg1;
87893   arg2 = (int)jarg2;
87894   arg3 = (int)jarg3;
87895   {
87896     try {
87897       try {
87898         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87899       }
87900       catch(std::out_of_range &_e) {
87901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87902         return ;
87903       }
87904       catch(std::invalid_argument &_e) {
87905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87906         return ;
87907       }
87908
87909     } catch (std::out_of_range& e) {
87910       {
87911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87912       };
87913     } catch (std::exception& e) {
87914       {
87915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87916       };
87917     } catch (...) {
87918       {
87919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87920       };
87921     }
87922   }
87923 }
87924
87925
87926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87927   void * jresult ;
87928   Dali::Actor *arg1 = 0 ;
87929   int arg2 ;
87930   std::vector< Dali::Actor > *result = 0 ;
87931
87932   arg1 = (Dali::Actor *)jarg1;
87933   if (!arg1) {
87934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87935     return 0;
87936   }
87937   arg2 = (int)jarg2;
87938   {
87939     try {
87940       try {
87941         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87942       }
87943       catch(std::out_of_range &_e) {
87944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87945         return 0;
87946       }
87947
87948     } catch (std::out_of_range& e) {
87949       {
87950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87951       };
87952     } catch (std::exception& e) {
87953       {
87954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87955       };
87956     } catch (...) {
87957       {
87958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87959       };
87960     }
87961   }
87962   jresult = (void *)result;
87963   return jresult;
87964 }
87965
87966
87967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87968   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87969
87970   arg1 = (std::vector< Dali::Actor > *)jarg1;
87971   {
87972     try {
87973       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87974     } catch (std::out_of_range& e) {
87975       {
87976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87977       };
87978     } catch (std::exception& e) {
87979       {
87980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87981       };
87982     } catch (...) {
87983       {
87984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87985       };
87986     }
87987   }
87988 }
87989
87990
87991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87992   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87993   int arg2 ;
87994   int arg3 ;
87995
87996   arg1 = (std::vector< Dali::Actor > *)jarg1;
87997   arg2 = (int)jarg2;
87998   arg3 = (int)jarg3;
87999   {
88000     try {
88001       try {
88002         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88003       }
88004       catch(std::out_of_range &_e) {
88005         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88006         return ;
88007       }
88008       catch(std::invalid_argument &_e) {
88009         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88010         return ;
88011       }
88012
88013     } catch (std::out_of_range& e) {
88014       {
88015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88016       };
88017     } catch (std::exception& e) {
88018       {
88019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88020       };
88021     } catch (...) {
88022       {
88023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88024       };
88025     }
88026   }
88027 }
88028
88029
88030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88031   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88032   int arg2 ;
88033   std::vector< Dali::Actor > *arg3 = 0 ;
88034
88035   arg1 = (std::vector< Dali::Actor > *)jarg1;
88036   arg2 = (int)jarg2;
88037   arg3 = (std::vector< Dali::Actor > *)jarg3;
88038   if (!arg3) {
88039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88040     return ;
88041   }
88042   {
88043     try {
88044       try {
88045         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88046       }
88047       catch(std::out_of_range &_e) {
88048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88049         return ;
88050       }
88051
88052     } catch (std::out_of_range& e) {
88053       {
88054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88055       };
88056     } catch (std::exception& e) {
88057       {
88058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88059       };
88060     } catch (...) {
88061       {
88062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88063       };
88064     }
88065   }
88066 }
88067
88068
88069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88070   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88071
88072   arg1 = (std::vector< Dali::Actor > *)jarg1;
88073   {
88074     try {
88075       delete arg1;
88076     } catch (std::out_of_range& e) {
88077       {
88078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88079       };
88080     } catch (std::exception& e) {
88081       {
88082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (...) {
88085       {
88086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88087       };
88088     }
88089   }
88090 }
88091
88092
88093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88094   unsigned int jresult ;
88095   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88096   bool result;
88097
88098   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88099   {
88100     try {
88101       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88102     } catch (std::out_of_range& e) {
88103       {
88104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88105       };
88106     } catch (std::exception& e) {
88107       {
88108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88109       };
88110     } catch (...) {
88111       {
88112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88113       };
88114     }
88115   }
88116   jresult = result;
88117   return jresult;
88118 }
88119
88120
88121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88122   unsigned long jresult ;
88123   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88124   std::size_t result;
88125
88126   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88127   {
88128     try {
88129       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88130     } catch (std::out_of_range& e) {
88131       {
88132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88133       };
88134     } catch (std::exception& e) {
88135       {
88136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88137       };
88138     } catch (...) {
88139       {
88140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88141       };
88142     }
88143   }
88144   jresult = (unsigned long)result;
88145   return jresult;
88146 }
88147
88148
88149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88150   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88151   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88152
88153   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88154   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88155   {
88156     try {
88157       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88165       };
88166     } catch (...) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88169       };
88170     }
88171   }
88172 }
88173
88174
88175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88176   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88177   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88178
88179   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88180   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88181   {
88182     try {
88183       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88184     } catch (std::out_of_range& e) {
88185       {
88186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88187       };
88188     } catch (std::exception& e) {
88189       {
88190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88191       };
88192     } catch (...) {
88193       {
88194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88195       };
88196     }
88197   }
88198 }
88199
88200
88201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88202   unsigned int jresult ;
88203   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88204   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88205   bool result;
88206
88207   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88208   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88209   if (!arg2) {
88210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88211     return 0;
88212   }
88213   {
88214     try {
88215       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88216     } catch (std::out_of_range& e) {
88217       {
88218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88219       };
88220     } catch (std::exception& e) {
88221       {
88222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88223       };
88224     } catch (...) {
88225       {
88226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88227       };
88228     }
88229   }
88230   jresult = result;
88231   return jresult;
88232 }
88233
88234
88235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88236   void * jresult ;
88237   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88238
88239   {
88240     try {
88241       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88242     } catch (std::out_of_range& e) {
88243       {
88244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88245       };
88246     } catch (std::exception& e) {
88247       {
88248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88249       };
88250     } catch (...) {
88251       {
88252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88253       };
88254     }
88255   }
88256   jresult = (void *)result;
88257   return jresult;
88258 }
88259
88260
88261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88262   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88263
88264   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88265   {
88266     try {
88267       delete arg1;
88268     } catch (std::out_of_range& e) {
88269       {
88270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88271       };
88272     } catch (std::exception& e) {
88273       {
88274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88275       };
88276     } catch (...) {
88277       {
88278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88279       };
88280     }
88281   }
88282 }
88283
88284
88285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88286   unsigned int jresult ;
88287   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88288   bool result;
88289
88290   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88291   {
88292     try {
88293       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);
88294     } catch (std::out_of_range& e) {
88295       {
88296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88297       };
88298     } catch (std::exception& e) {
88299       {
88300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88301       };
88302     } catch (...) {
88303       {
88304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88305       };
88306     }
88307   }
88308   jresult = result;
88309   return jresult;
88310 }
88311
88312
88313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88314   unsigned long jresult ;
88315   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88316   std::size_t result;
88317
88318   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88319   {
88320     try {
88321       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);
88322     } catch (std::out_of_range& e) {
88323       {
88324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88325       };
88326     } catch (std::exception& e) {
88327       {
88328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88329       };
88330     } catch (...) {
88331       {
88332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88333       };
88334     }
88335   }
88336   jresult = (unsigned long)result;
88337   return jresult;
88338 }
88339
88340
88341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88342   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88343   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88344
88345   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88346   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88347   {
88348     try {
88349       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88350     } catch (std::out_of_range& e) {
88351       {
88352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88353       };
88354     } catch (std::exception& e) {
88355       {
88356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88357       };
88358     } catch (...) {
88359       {
88360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88361       };
88362     }
88363   }
88364 }
88365
88366
88367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88368   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88369   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88370
88371   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88372   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88373   {
88374     try {
88375       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88376     } catch (std::out_of_range& e) {
88377       {
88378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88379       };
88380     } catch (std::exception& e) {
88381       {
88382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88383       };
88384     } catch (...) {
88385       {
88386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88387       };
88388     }
88389   }
88390 }
88391
88392
88393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88394   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88395   Dali::Actor arg2 ;
88396   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88397   Dali::Actor *argp2 ;
88398
88399   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88400   argp2 = (Dali::Actor *)jarg2;
88401   if (!argp2) {
88402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88403     return ;
88404   }
88405   arg2 = *argp2;
88406   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88407   {
88408     try {
88409       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88410     } catch (std::out_of_range& e) {
88411       {
88412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88413       };
88414     } catch (std::exception& e) {
88415       {
88416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88417       };
88418     } catch (...) {
88419       {
88420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88421       };
88422     }
88423   }
88424 }
88425
88426
88427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88428   void * jresult ;
88429   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88430
88431   {
88432     try {
88433       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88434     } catch (std::out_of_range& e) {
88435       {
88436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88437       };
88438     } catch (std::exception& e) {
88439       {
88440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88441       };
88442     } catch (...) {
88443       {
88444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88445       };
88446     }
88447   }
88448   jresult = (void *)result;
88449   return jresult;
88450 }
88451
88452
88453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88454   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88455
88456   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88457   {
88458     try {
88459       delete arg1;
88460     } catch (std::out_of_range& e) {
88461       {
88462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (std::exception& e) {
88465       {
88466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88467       };
88468     } catch (...) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88471       };
88472     }
88473   }
88474 }
88475
88476
88477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88478   unsigned int jresult ;
88479   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88480   bool result;
88481
88482   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88483   {
88484     try {
88485       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88486     } catch (std::out_of_range& e) {
88487       {
88488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88489       };
88490     } catch (std::exception& e) {
88491       {
88492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88493       };
88494     } catch (...) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88497       };
88498     }
88499   }
88500   jresult = result;
88501   return jresult;
88502 }
88503
88504
88505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88506   unsigned long jresult ;
88507   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88508   std::size_t result;
88509
88510   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88511   {
88512     try {
88513       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88514     } catch (std::out_of_range& e) {
88515       {
88516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (std::exception& e) {
88519       {
88520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88521       };
88522     } catch (...) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88525       };
88526     }
88527   }
88528   jresult = (unsigned long)result;
88529   return jresult;
88530 }
88531
88532
88533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88534   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88535   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88536
88537   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88538   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88539   {
88540     try {
88541       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88542     } catch (std::out_of_range& e) {
88543       {
88544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88545       };
88546     } catch (std::exception& e) {
88547       {
88548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88549       };
88550     } catch (...) {
88551       {
88552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88553       };
88554     }
88555   }
88556 }
88557
88558
88559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88560   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88561   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88562
88563   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88564   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88565   {
88566     try {
88567       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88568     } catch (std::out_of_range& e) {
88569       {
88570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88571       };
88572     } catch (std::exception& e) {
88573       {
88574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88575       };
88576     } catch (...) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88579       };
88580     }
88581   }
88582 }
88583
88584
88585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88586   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88587   Dali::Actor arg2 ;
88588   Dali::Actor arg3 ;
88589   Dali::Actor *argp2 ;
88590   Dali::Actor *argp3 ;
88591
88592   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88593   argp2 = (Dali::Actor *)jarg2;
88594   if (!argp2) {
88595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88596     return ;
88597   }
88598   arg2 = *argp2;
88599   argp3 = (Dali::Actor *)jarg3;
88600   if (!argp3) {
88601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88602     return ;
88603   }
88604   arg3 = *argp3;
88605   {
88606     try {
88607       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88608     } catch (std::out_of_range& e) {
88609       {
88610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88611       };
88612     } catch (std::exception& e) {
88613       {
88614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88615       };
88616     } catch (...) {
88617       {
88618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88619       };
88620     }
88621   }
88622 }
88623
88624
88625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88626   void * jresult ;
88627   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88628
88629   {
88630     try {
88631       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88632     } catch (std::out_of_range& e) {
88633       {
88634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88635       };
88636     } catch (std::exception& e) {
88637       {
88638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88639       };
88640     } catch (...) {
88641       {
88642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88643       };
88644     }
88645   }
88646   jresult = (void *)result;
88647   return jresult;
88648 }
88649
88650
88651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88652   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88653
88654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88655   {
88656     try {
88657       delete arg1;
88658     } catch (std::out_of_range& e) {
88659       {
88660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88661       };
88662     } catch (std::exception& e) {
88663       {
88664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88665       };
88666     } catch (...) {
88667       {
88668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88669       };
88670     }
88671   }
88672 }
88673
88674
88675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88676   unsigned int jresult ;
88677   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88678   bool result;
88679
88680   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88681   {
88682     try {
88683       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88684     } catch (std::out_of_range& e) {
88685       {
88686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88687       };
88688     } catch (std::exception& e) {
88689       {
88690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88691       };
88692     } catch (...) {
88693       {
88694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88695       };
88696     }
88697   }
88698   jresult = result;
88699   return jresult;
88700 }
88701
88702
88703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88704   unsigned long jresult ;
88705   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88706   std::size_t result;
88707
88708   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88709   {
88710     try {
88711       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88712     } catch (std::out_of_range& e) {
88713       {
88714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88715       };
88716     } catch (std::exception& e) {
88717       {
88718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88719       };
88720     } catch (...) {
88721       {
88722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88723       };
88724     }
88725   }
88726   jresult = (unsigned long)result;
88727   return jresult;
88728 }
88729
88730
88731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88732   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88733   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88734
88735   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88736   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88737   {
88738     try {
88739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88740     } catch (std::out_of_range& e) {
88741       {
88742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88743       };
88744     } catch (std::exception& e) {
88745       {
88746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88751       };
88752     }
88753   }
88754 }
88755
88756
88757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88758   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88759   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88760
88761   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88762   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88763   {
88764     try {
88765       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88766     } catch (std::out_of_range& e) {
88767       {
88768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88769       };
88770     } catch (std::exception& e) {
88771       {
88772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88773       };
88774     } catch (...) {
88775       {
88776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88777       };
88778     }
88779   }
88780 }
88781
88782
88783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88784   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88785   Dali::Actor arg2 ;
88786   bool arg3 ;
88787   Dali::Actor *argp2 ;
88788
88789   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88790   argp2 = (Dali::Actor *)jarg2;
88791   if (!argp2) {
88792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88793     return ;
88794   }
88795   arg2 = *argp2;
88796   arg3 = jarg3 ? true : false;
88797   {
88798     try {
88799       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88800     } catch (std::out_of_range& e) {
88801       {
88802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88803       };
88804     } catch (std::exception& e) {
88805       {
88806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88807       };
88808     } catch (...) {
88809       {
88810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88811       };
88812     }
88813   }
88814 }
88815
88816
88817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88818   void * jresult ;
88819   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88820
88821   {
88822     try {
88823       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88824     } catch (std::out_of_range& e) {
88825       {
88826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88827       };
88828     } catch (std::exception& e) {
88829       {
88830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88831       };
88832     } catch (...) {
88833       {
88834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88835       };
88836     }
88837   }
88838   jresult = (void *)result;
88839   return jresult;
88840 }
88841
88842
88843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88844   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88845
88846   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88847   {
88848     try {
88849       delete arg1;
88850     } catch (std::out_of_range& e) {
88851       {
88852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88853       };
88854     } catch (std::exception& e) {
88855       {
88856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88857       };
88858     } catch (...) {
88859       {
88860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88861       };
88862     }
88863   }
88864 }
88865
88866
88867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88868   unsigned int jresult ;
88869   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88870   bool result;
88871
88872   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88873   {
88874     try {
88875       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);
88876     } catch (std::out_of_range& e) {
88877       {
88878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (std::exception& e) {
88881       {
88882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88887       };
88888     }
88889   }
88890   jresult = result;
88891   return jresult;
88892 }
88893
88894
88895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88896   unsigned long jresult ;
88897   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88898   std::size_t result;
88899
88900   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88901   {
88902     try {
88903       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);
88904     } catch (std::out_of_range& e) {
88905       {
88906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88907       };
88908     } catch (std::exception& e) {
88909       {
88910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88911       };
88912     } catch (...) {
88913       {
88914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88915       };
88916     }
88917   }
88918   jresult = (unsigned long)result;
88919   return jresult;
88920 }
88921
88922
88923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88924   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88925   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88926
88927   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88928   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88929   {
88930     try {
88931       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88939       };
88940     } catch (...) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88943       };
88944     }
88945   }
88946 }
88947
88948
88949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88950   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88951   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88952
88953   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88954   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88955   {
88956     try {
88957       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88958     } catch (std::out_of_range& e) {
88959       {
88960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88961       };
88962     } catch (std::exception& e) {
88963       {
88964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88965       };
88966     } catch (...) {
88967       {
88968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88969       };
88970     }
88971   }
88972 }
88973
88974
88975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88976   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88977   Dali::Toolkit::StyleManager arg2 ;
88978   Dali::StyleChange::Type arg3 ;
88979   Dali::Toolkit::StyleManager *argp2 ;
88980
88981   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88982   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88983   if (!argp2) {
88984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88985     return ;
88986   }
88987   arg2 = *argp2;
88988   arg3 = (Dali::StyleChange::Type)jarg3;
88989   {
88990     try {
88991       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88992     } catch (std::out_of_range& e) {
88993       {
88994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88995       };
88996     } catch (std::exception& e) {
88997       {
88998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88999       };
89000     } catch (...) {
89001       {
89002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89003       };
89004     }
89005   }
89006 }
89007
89008
89009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89010   void * jresult ;
89011   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89012
89013   {
89014     try {
89015       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89016     } catch (std::out_of_range& e) {
89017       {
89018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (std::exception& e) {
89021       {
89022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89023       };
89024     } catch (...) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89027       };
89028     }
89029   }
89030   jresult = (void *)result;
89031   return jresult;
89032 }
89033
89034
89035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89036   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89037
89038   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89039   {
89040     try {
89041       delete arg1;
89042     } catch (std::out_of_range& e) {
89043       {
89044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89045       };
89046     } catch (std::exception& e) {
89047       {
89048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89049       };
89050     } catch (...) {
89051       {
89052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89053       };
89054     }
89055   }
89056 }
89057
89058
89059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89060   unsigned int jresult ;
89061   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89062   bool result;
89063
89064   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89065   {
89066     try {
89067       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89068     } catch (std::out_of_range& e) {
89069       {
89070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89071       };
89072     } catch (std::exception& e) {
89073       {
89074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89075       };
89076     } catch (...) {
89077       {
89078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89079       };
89080     }
89081   }
89082   jresult = result;
89083   return jresult;
89084 }
89085
89086
89087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89088   unsigned long jresult ;
89089   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89090   std::size_t result;
89091
89092   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89093   {
89094     try {
89095       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89096     } catch (std::out_of_range& e) {
89097       {
89098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89099       };
89100     } catch (std::exception& e) {
89101       {
89102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89103       };
89104     } catch (...) {
89105       {
89106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89107       };
89108     }
89109   }
89110   jresult = (unsigned long)result;
89111   return jresult;
89112 }
89113
89114
89115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89116   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89117   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89118
89119   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89120   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89121   {
89122     try {
89123       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89124     } catch (std::out_of_range& e) {
89125       {
89126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89127       };
89128     } catch (std::exception& e) {
89129       {
89130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89131       };
89132     } catch (...) {
89133       {
89134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89135       };
89136     }
89137   }
89138 }
89139
89140
89141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89142   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89143   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89144
89145   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89146   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89147   {
89148     try {
89149       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89150     } catch (std::out_of_range& e) {
89151       {
89152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89153       };
89154     } catch (std::exception& e) {
89155       {
89156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89157       };
89158     } catch (...) {
89159       {
89160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89161       };
89162     }
89163   }
89164 }
89165
89166
89167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89168   unsigned int jresult ;
89169   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89170   Dali::Toolkit::Button arg2 ;
89171   Dali::Toolkit::Button *argp2 ;
89172   bool result;
89173
89174   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89175   argp2 = (Dali::Toolkit::Button *)jarg2;
89176   if (!argp2) {
89177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89178     return 0;
89179   }
89180   arg2 = *argp2;
89181   {
89182     try {
89183       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89184     } catch (std::out_of_range& e) {
89185       {
89186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89187       };
89188     } catch (std::exception& e) {
89189       {
89190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89191       };
89192     } catch (...) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89195       };
89196     }
89197   }
89198   jresult = result;
89199   return jresult;
89200 }
89201
89202
89203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89204   void * jresult ;
89205   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89206
89207   {
89208     try {
89209       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89210     } catch (std::out_of_range& e) {
89211       {
89212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89213       };
89214     } catch (std::exception& e) {
89215       {
89216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89217       };
89218     } catch (...) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89221       };
89222     }
89223   }
89224   jresult = (void *)result;
89225   return jresult;
89226 }
89227
89228
89229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89230   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89231
89232   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89233   {
89234     try {
89235       delete arg1;
89236     } catch (std::out_of_range& e) {
89237       {
89238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89239       };
89240     } catch (std::exception& e) {
89241       {
89242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89243       };
89244     } catch (...) {
89245       {
89246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89247       };
89248     }
89249   }
89250 }
89251
89252
89253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89254   unsigned int jresult ;
89255   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89256   bool result;
89257
89258   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89259   {
89260     try {
89261       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89262     } catch (std::out_of_range& e) {
89263       {
89264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89265       };
89266     } catch (std::exception& e) {
89267       {
89268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89269       };
89270     } catch (...) {
89271       {
89272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89273       };
89274     }
89275   }
89276   jresult = result;
89277   return jresult;
89278 }
89279
89280
89281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89282   unsigned long jresult ;
89283   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89284   std::size_t result;
89285
89286   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89287   {
89288     try {
89289       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89290     } catch (std::out_of_range& e) {
89291       {
89292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89293       };
89294     } catch (std::exception& e) {
89295       {
89296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89301       };
89302     }
89303   }
89304   jresult = (unsigned long)result;
89305   return jresult;
89306 }
89307
89308
89309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89310   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89311   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89312
89313   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89314   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89315   {
89316     try {
89317       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89318     } catch (std::out_of_range& e) {
89319       {
89320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89321       };
89322     } catch (std::exception& e) {
89323       {
89324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89325       };
89326     } catch (...) {
89327       {
89328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89329       };
89330     }
89331   }
89332 }
89333
89334
89335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89336   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89337   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89338
89339   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89340   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89341   {
89342     try {
89343       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89344     } catch (std::out_of_range& e) {
89345       {
89346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89347       };
89348     } catch (std::exception& e) {
89349       {
89350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89351       };
89352     } catch (...) {
89353       {
89354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89355       };
89356     }
89357   }
89358 }
89359
89360
89361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89362   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89363   Dali::Toolkit::GaussianBlurView arg2 ;
89364   Dali::Toolkit::GaussianBlurView *argp2 ;
89365
89366   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89367   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89368   if (!argp2) {
89369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89370     return ;
89371   }
89372   arg2 = *argp2;
89373   {
89374     try {
89375       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89376     } catch (std::out_of_range& e) {
89377       {
89378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89379       };
89380     } catch (std::exception& e) {
89381       {
89382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89383       };
89384     } catch (...) {
89385       {
89386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89387       };
89388     }
89389   }
89390 }
89391
89392
89393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89394   void * jresult ;
89395   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89396
89397   {
89398     try {
89399       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89400     } catch (std::out_of_range& e) {
89401       {
89402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89403       };
89404     } catch (std::exception& e) {
89405       {
89406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89407       };
89408     } catch (...) {
89409       {
89410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89411       };
89412     }
89413   }
89414   jresult = (void *)result;
89415   return jresult;
89416 }
89417
89418
89419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89420   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89421
89422   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89423   {
89424     try {
89425       delete arg1;
89426     } catch (std::out_of_range& e) {
89427       {
89428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89429       };
89430     } catch (std::exception& e) {
89431       {
89432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89433       };
89434     } catch (...) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89437       };
89438     }
89439   }
89440 }
89441
89442
89443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89444   unsigned int jresult ;
89445   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89446   bool result;
89447
89448   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89449   {
89450     try {
89451       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);
89452     } catch (std::out_of_range& e) {
89453       {
89454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (std::exception& e) {
89457       {
89458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89463       };
89464     }
89465   }
89466   jresult = result;
89467   return jresult;
89468 }
89469
89470
89471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89472   unsigned long jresult ;
89473   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89474   std::size_t result;
89475
89476   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89477   {
89478     try {
89479       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);
89480     } catch (std::out_of_range& e) {
89481       {
89482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89483       };
89484     } catch (std::exception& e) {
89485       {
89486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89487       };
89488     } catch (...) {
89489       {
89490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89491       };
89492     }
89493   }
89494   jresult = (unsigned long)result;
89495   return jresult;
89496 }
89497
89498
89499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89500   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89501   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89502
89503   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89504   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89505   {
89506     try {
89507       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89515       };
89516     } catch (...) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89519       };
89520     }
89521   }
89522 }
89523
89524
89525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89526   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89527   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89528
89529   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89530   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89531   {
89532     try {
89533       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89534     } catch (std::out_of_range& e) {
89535       {
89536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89537       };
89538     } catch (std::exception& e) {
89539       {
89540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89541       };
89542     } catch (...) {
89543       {
89544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89545       };
89546     }
89547   }
89548 }
89549
89550
89551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89552   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89553   Dali::Toolkit::PageTurnView arg2 ;
89554   unsigned int arg3 ;
89555   bool arg4 ;
89556   Dali::Toolkit::PageTurnView *argp2 ;
89557
89558   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89559   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89560   if (!argp2) {
89561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89562     return ;
89563   }
89564   arg2 = *argp2;
89565   arg3 = (unsigned int)jarg3;
89566   arg4 = jarg4 ? true : false;
89567   {
89568     try {
89569       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89570     } catch (std::out_of_range& e) {
89571       {
89572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89573       };
89574     } catch (std::exception& e) {
89575       {
89576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89577       };
89578     } catch (...) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89581       };
89582     }
89583   }
89584 }
89585
89586
89587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89588   void * jresult ;
89589   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89590
89591   {
89592     try {
89593       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89594     } catch (std::out_of_range& e) {
89595       {
89596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89597       };
89598     } catch (std::exception& e) {
89599       {
89600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (...) {
89603       {
89604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89605       };
89606     }
89607   }
89608   jresult = (void *)result;
89609   return jresult;
89610 }
89611
89612
89613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89614   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89615
89616   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89617   {
89618     try {
89619       delete arg1;
89620     } catch (std::out_of_range& e) {
89621       {
89622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89623       };
89624     } catch (std::exception& e) {
89625       {
89626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89631       };
89632     }
89633   }
89634 }
89635
89636
89637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89638   unsigned int jresult ;
89639   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89640   bool result;
89641
89642   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89643   {
89644     try {
89645       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89646     } catch (std::out_of_range& e) {
89647       {
89648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89649       };
89650     } catch (std::exception& e) {
89651       {
89652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89657       };
89658     }
89659   }
89660   jresult = result;
89661   return jresult;
89662 }
89663
89664
89665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89666   unsigned long jresult ;
89667   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89668   std::size_t result;
89669
89670   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89671   {
89672     try {
89673       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89674     } catch (std::out_of_range& e) {
89675       {
89676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89677       };
89678     } catch (std::exception& e) {
89679       {
89680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89681       };
89682     } catch (...) {
89683       {
89684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89685       };
89686     }
89687   }
89688   jresult = (unsigned long)result;
89689   return jresult;
89690 }
89691
89692
89693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89694   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89695   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89696
89697   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89698   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89699   {
89700     try {
89701       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89702     } catch (std::out_of_range& e) {
89703       {
89704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89705       };
89706     } catch (std::exception& e) {
89707       {
89708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (...) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89713       };
89714     }
89715   }
89716 }
89717
89718
89719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89720   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89721   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89722
89723   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89724   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89725   {
89726     try {
89727       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89728     } catch (std::out_of_range& e) {
89729       {
89730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89731       };
89732     } catch (std::exception& e) {
89733       {
89734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89735       };
89736     } catch (...) {
89737       {
89738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89739       };
89740     }
89741   }
89742 }
89743
89744
89745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89746   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89747   Dali::Toolkit::PageTurnView arg2 ;
89748   Dali::Toolkit::PageTurnView *argp2 ;
89749
89750   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89751   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89752   if (!argp2) {
89753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89754     return ;
89755   }
89756   arg2 = *argp2;
89757   {
89758     try {
89759       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89760     } catch (std::out_of_range& e) {
89761       {
89762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89763       };
89764     } catch (std::exception& e) {
89765       {
89766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89767       };
89768     } catch (...) {
89769       {
89770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89771       };
89772     }
89773   }
89774 }
89775
89776
89777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89778   void * jresult ;
89779   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89780
89781   {
89782     try {
89783       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89784     } catch (std::out_of_range& e) {
89785       {
89786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89787       };
89788     } catch (std::exception& e) {
89789       {
89790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89791       };
89792     } catch (...) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89795       };
89796     }
89797   }
89798   jresult = (void *)result;
89799   return jresult;
89800 }
89801
89802
89803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89804   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89805
89806   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89807   {
89808     try {
89809       delete arg1;
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (...) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89821       };
89822     }
89823   }
89824 }
89825
89826
89827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89828   unsigned int jresult ;
89829   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89830   bool result;
89831
89832   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89833   {
89834     try {
89835       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);
89836     } catch (std::out_of_range& e) {
89837       {
89838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89839       };
89840     } catch (std::exception& e) {
89841       {
89842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (...) {
89845       {
89846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89847       };
89848     }
89849   }
89850   jresult = result;
89851   return jresult;
89852 }
89853
89854
89855 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89856   unsigned long jresult ;
89857   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89858   std::size_t result;
89859
89860   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89861   {
89862     try {
89863       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);
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (...) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89875       };
89876     }
89877   }
89878   jresult = (unsigned long)result;
89879   return jresult;
89880 }
89881
89882
89883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89884   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89885   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89886
89887   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89888   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89889   {
89890     try {
89891       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89892     } catch (std::out_of_range& e) {
89893       {
89894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (std::exception& e) {
89897       {
89898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89903       };
89904     }
89905   }
89906 }
89907
89908
89909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89910   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89911   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89912
89913   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89914   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89915   {
89916     try {
89917       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
89918     } catch (std::out_of_range& e) {
89919       {
89920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89921       };
89922     } catch (std::exception& e) {
89923       {
89924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89925       };
89926     } catch (...) {
89927       {
89928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89929       };
89930     }
89931   }
89932 }
89933
89934
89935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
89936   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89937   Dali::Toolkit::ProgressBar arg2 ;
89938   float arg3 ;
89939   float arg4 ;
89940   Dali::Toolkit::ProgressBar *argp2 ;
89941
89942   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89943   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
89944   if (!argp2) {
89945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
89946     return ;
89947   }
89948   arg2 = *argp2;
89949   arg3 = (float)jarg3;
89950   arg4 = (float)jarg4;
89951   {
89952     try {
89953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89954     } catch (std::out_of_range& e) {
89955       {
89956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89957       };
89958     } catch (std::exception& e) {
89959       {
89960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89961       };
89962     } catch (...) {
89963       {
89964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89965       };
89966     }
89967   }
89968 }
89969
89970
89971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
89972   void * jresult ;
89973   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
89974
89975   {
89976     try {
89977       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
89978     } catch (std::out_of_range& e) {
89979       {
89980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (std::exception& e) {
89983       {
89984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89985       };
89986     } catch (...) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89989       };
89990     }
89991   }
89992   jresult = (void *)result;
89993   return jresult;
89994 }
89995
89996
89997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
89998   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89999
90000   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90001   {
90002     try {
90003       delete arg1;
90004     } catch (std::out_of_range& e) {
90005       {
90006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (std::exception& e) {
90009       {
90010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018 }
90019
90020
90021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90022   unsigned int jresult ;
90023   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90024   bool result;
90025
90026   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90027   {
90028     try {
90029       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);
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90041       };
90042     }
90043   }
90044   jresult = result;
90045   return jresult;
90046 }
90047
90048
90049 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90050   unsigned long jresult ;
90051   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90052   std::size_t result;
90053
90054   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90055   {
90056     try {
90057       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);
90058     } catch (std::out_of_range& e) {
90059       {
90060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90061       };
90062     } catch (std::exception& e) {
90063       {
90064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90065       };
90066     } catch (...) {
90067       {
90068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90069       };
90070     }
90071   }
90072   jresult = (unsigned long)result;
90073   return jresult;
90074 }
90075
90076
90077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90078   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90079   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90080
90081   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90082   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90083   {
90084     try {
90085       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90086     } catch (std::out_of_range& e) {
90087       {
90088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90089       };
90090     } catch (std::exception& e) {
90091       {
90092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90097       };
90098     }
90099   }
90100 }
90101
90102
90103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90104   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90105   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90106
90107   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90108   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90109   {
90110     try {
90111       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90112     } catch (std::out_of_range& e) {
90113       {
90114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90115       };
90116     } catch (std::exception& e) {
90117       {
90118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90119       };
90120     } catch (...) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90123       };
90124     }
90125   }
90126 }
90127
90128
90129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90130   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90131   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90132
90133   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90134   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90135   if (!arg2) {
90136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90137     return ;
90138   }
90139   {
90140     try {
90141       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90142     } catch (std::out_of_range& e) {
90143       {
90144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90145       };
90146     } catch (std::exception& e) {
90147       {
90148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90149       };
90150     } catch (...) {
90151       {
90152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90153       };
90154     }
90155   }
90156 }
90157
90158
90159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90160   void * jresult ;
90161   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90162
90163   {
90164     try {
90165       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90166     } catch (std::out_of_range& e) {
90167       {
90168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90169       };
90170     } catch (std::exception& e) {
90171       {
90172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90173       };
90174     } catch (...) {
90175       {
90176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90177       };
90178     }
90179   }
90180   jresult = (void *)result;
90181   return jresult;
90182 }
90183
90184
90185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90186   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90187
90188   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90189   {
90190     try {
90191       delete arg1;
90192     } catch (std::out_of_range& e) {
90193       {
90194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90195       };
90196     } catch (std::exception& e) {
90197       {
90198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90199       };
90200     } catch (...) {
90201       {
90202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90203       };
90204     }
90205   }
90206 }
90207
90208
90209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90210   unsigned int jresult ;
90211   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90212   bool result;
90213
90214   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90215   {
90216     try {
90217       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90218     } catch (std::out_of_range& e) {
90219       {
90220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90221       };
90222     } catch (std::exception& e) {
90223       {
90224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90225       };
90226     } catch (...) {
90227       {
90228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90229       };
90230     }
90231   }
90232   jresult = result;
90233   return jresult;
90234 }
90235
90236
90237 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90238   unsigned long jresult ;
90239   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90240   std::size_t result;
90241
90242   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90243   {
90244     try {
90245       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90246     } catch (std::out_of_range& e) {
90247       {
90248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90249       };
90250     } catch (std::exception& e) {
90251       {
90252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90253       };
90254     } catch (...) {
90255       {
90256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90257       };
90258     }
90259   }
90260   jresult = (unsigned long)result;
90261   return jresult;
90262 }
90263
90264
90265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90266   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90267   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90268
90269   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90270   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90271   {
90272     try {
90273       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90274     } catch (std::out_of_range& e) {
90275       {
90276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90277       };
90278     } catch (std::exception& e) {
90279       {
90280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90281       };
90282     } catch (...) {
90283       {
90284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90285       };
90286     }
90287   }
90288 }
90289
90290
90291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90292   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90293   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90294
90295   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90296   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90297   {
90298     try {
90299       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90300     } catch (std::out_of_range& e) {
90301       {
90302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90303       };
90304     } catch (std::exception& e) {
90305       {
90306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90307       };
90308     } catch (...) {
90309       {
90310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90311       };
90312     }
90313   }
90314 }
90315
90316
90317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90318   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90319   Dali::Vector2 *arg2 = 0 ;
90320
90321   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90322   arg2 = (Dali::Vector2 *)jarg2;
90323   if (!arg2) {
90324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90325     return ;
90326   }
90327   {
90328     try {
90329       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90330     } catch (std::out_of_range& e) {
90331       {
90332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90333       };
90334     } catch (std::exception& e) {
90335       {
90336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90337       };
90338     } catch (...) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90341       };
90342     }
90343   }
90344 }
90345
90346
90347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90348   void * jresult ;
90349   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90350
90351   {
90352     try {
90353       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90354     } catch (std::out_of_range& e) {
90355       {
90356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90357       };
90358     } catch (std::exception& e) {
90359       {
90360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (...) {
90363       {
90364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90365       };
90366     }
90367   }
90368   jresult = (void *)result;
90369   return jresult;
90370 }
90371
90372
90373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90374   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90375
90376   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90377   {
90378     try {
90379       delete arg1;
90380     } catch (std::out_of_range& e) {
90381       {
90382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90383       };
90384     } catch (std::exception& e) {
90385       {
90386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90387       };
90388     } catch (...) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90391       };
90392     }
90393   }
90394 }
90395
90396
90397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90398   unsigned int jresult ;
90399   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90400   bool result;
90401
90402   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90403   {
90404     try {
90405       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90406     } catch (std::out_of_range& e) {
90407       {
90408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90409       };
90410     } catch (std::exception& e) {
90411       {
90412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90413       };
90414     } catch (...) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90417       };
90418     }
90419   }
90420   jresult = result;
90421   return jresult;
90422 }
90423
90424
90425 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90426   unsigned long jresult ;
90427   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90428   std::size_t result;
90429
90430   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90431   {
90432     try {
90433       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90434     } catch (std::out_of_range& e) {
90435       {
90436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90437       };
90438     } catch (std::exception& e) {
90439       {
90440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90441       };
90442     } catch (...) {
90443       {
90444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90445       };
90446     }
90447   }
90448   jresult = (unsigned long)result;
90449   return jresult;
90450 }
90451
90452
90453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90454   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90455   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90456
90457   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90458   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90459   {
90460     try {
90461       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90469       };
90470     } catch (...) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90473       };
90474     }
90475   }
90476 }
90477
90478
90479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90480   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90481   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90482
90483   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90484   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90485   {
90486     try {
90487       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90488     } catch (std::out_of_range& e) {
90489       {
90490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90491       };
90492     } catch (std::exception& e) {
90493       {
90494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90495       };
90496     } catch (...) {
90497       {
90498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90499       };
90500     }
90501   }
90502 }
90503
90504
90505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90506   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90507   Dali::Toolkit::TextEditor arg2 ;
90508   Dali::Toolkit::TextEditor *argp2 ;
90509
90510   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90511   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90512   if (!argp2) {
90513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90514     return ;
90515   }
90516   arg2 = *argp2;
90517   {
90518     try {
90519       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90520     } catch (std::out_of_range& e) {
90521       {
90522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90523       };
90524     } catch (std::exception& e) {
90525       {
90526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90527       };
90528     } catch (...) {
90529       {
90530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90531       };
90532     }
90533   }
90534 }
90535
90536
90537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90538   void * jresult ;
90539   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90540
90541   {
90542     try {
90543       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90544     } catch (std::out_of_range& e) {
90545       {
90546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90547       };
90548     } catch (std::exception& e) {
90549       {
90550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90551       };
90552     } catch (...) {
90553       {
90554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90555       };
90556     }
90557   }
90558   jresult = (void *)result;
90559   return jresult;
90560 }
90561
90562
90563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90564   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90565
90566   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90567   {
90568     try {
90569       delete arg1;
90570     } catch (std::out_of_range& e) {
90571       {
90572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90573       };
90574     } catch (std::exception& e) {
90575       {
90576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90577       };
90578     } catch (...) {
90579       {
90580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90581       };
90582     }
90583   }
90584 }
90585
90586
90587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90588   unsigned int jresult ;
90589   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90590   bool result;
90591
90592   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90593   {
90594     try {
90595       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90596     } catch (std::out_of_range& e) {
90597       {
90598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90599       };
90600     } catch (std::exception& e) {
90601       {
90602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90603       };
90604     } catch (...) {
90605       {
90606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90607       };
90608     }
90609   }
90610   jresult = result;
90611   return jresult;
90612 }
90613
90614
90615 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90616   unsigned long jresult ;
90617   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90618   std::size_t result;
90619
90620   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90621   {
90622     try {
90623       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90624     } catch (std::out_of_range& e) {
90625       {
90626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90627       };
90628     } catch (std::exception& e) {
90629       {
90630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90631       };
90632     } catch (...) {
90633       {
90634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90635       };
90636     }
90637   }
90638   jresult = (unsigned long)result;
90639   return jresult;
90640 }
90641
90642
90643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90644   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90645   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90646
90647   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90648   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90649   {
90650     try {
90651       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90652     } catch (std::out_of_range& e) {
90653       {
90654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90655       };
90656     } catch (std::exception& e) {
90657       {
90658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90659       };
90660     } catch (...) {
90661       {
90662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90663       };
90664     }
90665   }
90666 }
90667
90668
90669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90670   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90671   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90672
90673   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90674   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90675   {
90676     try {
90677       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90685       };
90686     } catch (...) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90689       };
90690     }
90691   }
90692 }
90693
90694
90695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90696   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90697   Dali::Toolkit::TextField arg2 ;
90698   Dali::Toolkit::TextField *argp2 ;
90699
90700   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90701   argp2 = (Dali::Toolkit::TextField *)jarg2;
90702   if (!argp2) {
90703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90704     return ;
90705   }
90706   arg2 = *argp2;
90707   {
90708     try {
90709       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90710     } catch (std::out_of_range& e) {
90711       {
90712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90713       };
90714     } catch (std::exception& e) {
90715       {
90716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90717       };
90718     } catch (...) {
90719       {
90720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90721       };
90722     }
90723   }
90724 }
90725
90726
90727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90728   void * jresult ;
90729   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90730
90731   {
90732     try {
90733       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90734     } catch (std::out_of_range& e) {
90735       {
90736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90737       };
90738     } catch (std::exception& e) {
90739       {
90740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (...) {
90743       {
90744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90745       };
90746     }
90747   }
90748   jresult = (void *)result;
90749   return jresult;
90750 }
90751
90752
90753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90754   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90755
90756   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90757   {
90758     try {
90759       delete arg1;
90760     } catch (std::out_of_range& e) {
90761       {
90762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90763       };
90764     } catch (std::exception& e) {
90765       {
90766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90767       };
90768     } catch (...) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90771       };
90772     }
90773   }
90774 }
90775
90776
90777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90778   unsigned int jresult ;
90779   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90780   bool result;
90781
90782   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90783   {
90784     try {
90785       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);
90786     } catch (std::out_of_range& e) {
90787       {
90788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90789       };
90790     } catch (std::exception& e) {
90791       {
90792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (...) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90797       };
90798     }
90799   }
90800   jresult = result;
90801   return jresult;
90802 }
90803
90804
90805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90806   unsigned long jresult ;
90807   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90808   std::size_t result;
90809
90810   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90811   {
90812     try {
90813       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);
90814     } catch (std::out_of_range& e) {
90815       {
90816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90817       };
90818     } catch (std::exception& e) {
90819       {
90820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90821       };
90822     } catch (...) {
90823       {
90824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90825       };
90826     }
90827   }
90828   jresult = (unsigned long)result;
90829   return jresult;
90830 }
90831
90832
90833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90834   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90835   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90836
90837   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90838   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90839   {
90840     try {
90841       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90842     } catch (std::out_of_range& e) {
90843       {
90844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90845       };
90846     } catch (std::exception& e) {
90847       {
90848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90849       };
90850     } catch (...) {
90851       {
90852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90853       };
90854     }
90855   }
90856 }
90857
90858
90859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90860   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90861   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90862
90863   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90864   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90865   {
90866     try {
90867       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90868     } catch (std::out_of_range& e) {
90869       {
90870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90871       };
90872     } catch (std::exception& e) {
90873       {
90874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90875       };
90876     } catch (...) {
90877       {
90878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90879       };
90880     }
90881   }
90882 }
90883
90884
90885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90886   unsigned int jresult ;
90887   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90888   Dali::Toolkit::Control arg2 ;
90889   Dali::KeyEvent *arg3 = 0 ;
90890   Dali::Toolkit::Control *argp2 ;
90891   bool result;
90892
90893   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90894   argp2 = (Dali::Toolkit::Control *)jarg2;
90895   if (!argp2) {
90896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90897     return 0;
90898   }
90899   arg2 = *argp2;
90900   arg3 = (Dali::KeyEvent *)jarg3;
90901   if (!arg3) {
90902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90903     return 0;
90904   }
90905   {
90906     try {
90907       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);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (...) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90919       };
90920     }
90921   }
90922   jresult = result;
90923   return jresult;
90924 }
90925
90926
90927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90928   void * jresult ;
90929   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90930
90931   {
90932     try {
90933       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90934     } catch (std::out_of_range& e) {
90935       {
90936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90937       };
90938     } catch (std::exception& e) {
90939       {
90940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90941       };
90942     } catch (...) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90945       };
90946     }
90947   }
90948   jresult = (void *)result;
90949   return jresult;
90950 }
90951
90952
90953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90954   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90955
90956   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90957   {
90958     try {
90959       delete arg1;
90960     } catch (std::out_of_range& e) {
90961       {
90962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90963       };
90964     } catch (std::exception& e) {
90965       {
90966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90967       };
90968     } catch (...) {
90969       {
90970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90971       };
90972     }
90973   }
90974 }
90975
90976
90977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90978   unsigned int jresult ;
90979   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90980   bool result;
90981
90982   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90983   {
90984     try {
90985       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90986     } catch (std::out_of_range& e) {
90987       {
90988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90989       };
90990     } catch (std::exception& e) {
90991       {
90992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90993       };
90994     } catch (...) {
90995       {
90996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90997       };
90998     }
90999   }
91000   jresult = result;
91001   return jresult;
91002 }
91003
91004
91005 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91006   unsigned long jresult ;
91007   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91008   std::size_t result;
91009
91010   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91011   {
91012     try {
91013       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91014     } catch (std::out_of_range& e) {
91015       {
91016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91017       };
91018     } catch (std::exception& e) {
91019       {
91020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91021       };
91022     } catch (...) {
91023       {
91024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91025       };
91026     }
91027   }
91028   jresult = (unsigned long)result;
91029   return jresult;
91030 }
91031
91032
91033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91034   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91035   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91036
91037   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91038   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91039   {
91040     try {
91041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91042     } catch (std::out_of_range& e) {
91043       {
91044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91045       };
91046     } catch (std::exception& e) {
91047       {
91048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91049       };
91050     } catch (...) {
91051       {
91052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91053       };
91054     }
91055   }
91056 }
91057
91058
91059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91060   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91061   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91062
91063   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91064   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91065   {
91066     try {
91067       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91068     } catch (std::out_of_range& e) {
91069       {
91070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91071       };
91072     } catch (std::exception& e) {
91073       {
91074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91075       };
91076     } catch (...) {
91077       {
91078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91079       };
91080     }
91081   }
91082 }
91083
91084
91085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91086   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91087   Dali::Toolkit::Control arg2 ;
91088   Dali::Toolkit::Control *argp2 ;
91089
91090   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91091   argp2 = (Dali::Toolkit::Control *)jarg2;
91092   if (!argp2) {
91093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91094     return ;
91095   }
91096   arg2 = *argp2;
91097   {
91098     try {
91099       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91100     } catch (std::out_of_range& e) {
91101       {
91102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91103       };
91104     } catch (std::exception& e) {
91105       {
91106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91107       };
91108     } catch (...) {
91109       {
91110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91111       };
91112     }
91113   }
91114 }
91115
91116
91117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91118   void * jresult ;
91119   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91120
91121   {
91122     try {
91123       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91124     } catch (std::out_of_range& e) {
91125       {
91126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91127       };
91128     } catch (std::exception& e) {
91129       {
91130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91131       };
91132     } catch (...) {
91133       {
91134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91135       };
91136     }
91137   }
91138   jresult = (void *)result;
91139   return jresult;
91140 }
91141
91142
91143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91144   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91145
91146   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91147   {
91148     try {
91149       delete arg1;
91150     } catch (std::out_of_range& e) {
91151       {
91152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91153       };
91154     } catch (std::exception& e) {
91155       {
91156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91157       };
91158     } catch (...) {
91159       {
91160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91161       };
91162     }
91163   }
91164 }
91165
91166
91167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91168   unsigned int jresult ;
91169   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91170   bool result;
91171
91172   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91173   {
91174     try {
91175       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91176     } catch (std::out_of_range& e) {
91177       {
91178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91179       };
91180     } catch (std::exception& e) {
91181       {
91182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91183       };
91184     } catch (...) {
91185       {
91186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91187       };
91188     }
91189   }
91190   jresult = result;
91191   return jresult;
91192 }
91193
91194
91195 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91196   unsigned long jresult ;
91197   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91198   std::size_t result;
91199
91200   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91201   {
91202     try {
91203       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91204     } catch (std::out_of_range& e) {
91205       {
91206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91207       };
91208     } catch (std::exception& e) {
91209       {
91210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91211       };
91212     } catch (...) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91215       };
91216     }
91217   }
91218   jresult = (unsigned long)result;
91219   return jresult;
91220 }
91221
91222
91223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91224   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91225   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91226
91227   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91228   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91229   {
91230     try {
91231       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91232     } catch (std::out_of_range& e) {
91233       {
91234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91235       };
91236     } catch (std::exception& e) {
91237       {
91238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91239       };
91240     } catch (...) {
91241       {
91242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91243       };
91244     }
91245   }
91246 }
91247
91248
91249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91250   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91251   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91252
91253   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91254   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91255   {
91256     try {
91257       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91258     } catch (std::out_of_range& e) {
91259       {
91260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91261       };
91262     } catch (std::exception& e) {
91263       {
91264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91265       };
91266     } catch (...) {
91267       {
91268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91269       };
91270     }
91271   }
91272 }
91273
91274
91275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91276   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91277   Dali::Toolkit::VideoView *arg2 = 0 ;
91278
91279   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91280   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91281   if (!arg2) {
91282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91283     return ;
91284   }
91285   {
91286     try {
91287       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91288     } catch (std::out_of_range& e) {
91289       {
91290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91291       };
91292     } catch (std::exception& e) {
91293       {
91294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91295       };
91296     } catch (...) {
91297       {
91298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91299       };
91300     }
91301   }
91302 }
91303
91304
91305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91306   void * jresult ;
91307   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91308
91309   {
91310     try {
91311       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91312     } catch (std::out_of_range& e) {
91313       {
91314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (std::exception& e) {
91317       {
91318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (...) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91323       };
91324     }
91325   }
91326   jresult = (void *)result;
91327   return jresult;
91328 }
91329
91330
91331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91332   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91333
91334   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91335   {
91336     try {
91337       delete arg1;
91338     } catch (std::out_of_range& e) {
91339       {
91340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91341       };
91342     } catch (std::exception& e) {
91343       {
91344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91345       };
91346     } catch (...) {
91347       {
91348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91349       };
91350     }
91351   }
91352 }
91353
91354
91355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91356   unsigned int jresult ;
91357   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91358   bool result;
91359
91360   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91361   {
91362     try {
91363       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91364     } catch (std::out_of_range& e) {
91365       {
91366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91367       };
91368     } catch (std::exception& e) {
91369       {
91370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91371       };
91372     } catch (...) {
91373       {
91374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91375       };
91376     }
91377   }
91378   jresult = result;
91379   return jresult;
91380 }
91381
91382
91383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91384   unsigned long jresult ;
91385   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91386   std::size_t result;
91387
91388   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91389   {
91390     try {
91391       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91392     } catch (std::out_of_range& e) {
91393       {
91394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91395       };
91396     } catch (std::exception& e) {
91397       {
91398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91399       };
91400     } catch (...) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91403       };
91404     }
91405   }
91406   jresult = (unsigned long)result;
91407   return jresult;
91408 }
91409
91410
91411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91412   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91413   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91414
91415   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91416   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91417   {
91418     try {
91419       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91420     } catch (std::out_of_range& e) {
91421       {
91422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91423       };
91424     } catch (std::exception& e) {
91425       {
91426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91427       };
91428     } catch (...) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91431       };
91432     }
91433   }
91434 }
91435
91436
91437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91438   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91439   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91440
91441   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91442   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91443   {
91444     try {
91445       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91446     } catch (std::out_of_range& e) {
91447       {
91448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91449       };
91450     } catch (std::exception& e) {
91451       {
91452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91453       };
91454     } catch (...) {
91455       {
91456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91457       };
91458     }
91459   }
91460 }
91461
91462
91463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91464   unsigned int jresult ;
91465   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91466   Dali::Toolkit::Slider arg2 ;
91467   float arg3 ;
91468   Dali::Toolkit::Slider *argp2 ;
91469   bool result;
91470
91471   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91472   argp2 = (Dali::Toolkit::Slider *)jarg2;
91473   if (!argp2) {
91474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91475     return 0;
91476   }
91477   arg2 = *argp2;
91478   arg3 = (float)jarg3;
91479   {
91480     try {
91481       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91482     } catch (std::out_of_range& e) {
91483       {
91484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (std::exception& e) {
91487       {
91488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91489       };
91490     } catch (...) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91493       };
91494     }
91495   }
91496   jresult = result;
91497   return jresult;
91498 }
91499
91500
91501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91502   void * jresult ;
91503   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91504
91505   {
91506     try {
91507       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91508     } catch (std::out_of_range& e) {
91509       {
91510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (std::exception& e) {
91513       {
91514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91515       };
91516     } catch (...) {
91517       {
91518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91519       };
91520     }
91521   }
91522   jresult = (void *)result;
91523   return jresult;
91524 }
91525
91526
91527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91528   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91529
91530   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91531   {
91532     try {
91533       delete arg1;
91534     } catch (std::out_of_range& e) {
91535       {
91536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91537       };
91538     } catch (std::exception& e) {
91539       {
91540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91541       };
91542     } catch (...) {
91543       {
91544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91545       };
91546     }
91547   }
91548 }
91549
91550
91551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91552   unsigned int jresult ;
91553   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91554   bool result;
91555
91556   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91557   {
91558     try {
91559       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91560     } catch (std::out_of_range& e) {
91561       {
91562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91563       };
91564     } catch (std::exception& e) {
91565       {
91566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91571       };
91572     }
91573   }
91574   jresult = result;
91575   return jresult;
91576 }
91577
91578
91579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91580   unsigned long jresult ;
91581   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91582   std::size_t result;
91583
91584   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91585   {
91586     try {
91587       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91588     } catch (std::out_of_range& e) {
91589       {
91590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91591       };
91592     } catch (std::exception& e) {
91593       {
91594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (...) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91599       };
91600     }
91601   }
91602   jresult = (unsigned long)result;
91603   return jresult;
91604 }
91605
91606
91607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91608   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91609   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91610
91611   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91612   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91613   {
91614     try {
91615       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91623       };
91624     } catch (...) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91627       };
91628     }
91629   }
91630 }
91631
91632
91633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91634   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91635   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91636
91637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91638   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91639   {
91640     try {
91641       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91649       };
91650     } catch (...) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91653       };
91654     }
91655   }
91656 }
91657
91658
91659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91660   unsigned int jresult ;
91661   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91662   Dali::Toolkit::Slider arg2 ;
91663   int arg3 ;
91664   Dali::Toolkit::Slider *argp2 ;
91665   bool result;
91666
91667   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91668   argp2 = (Dali::Toolkit::Slider *)jarg2;
91669   if (!argp2) {
91670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91671     return 0;
91672   }
91673   arg2 = *argp2;
91674   arg3 = (int)jarg3;
91675   {
91676     try {
91677       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91678     } catch (std::out_of_range& e) {
91679       {
91680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91681       };
91682     } catch (std::exception& e) {
91683       {
91684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91685       };
91686     } catch (...) {
91687       {
91688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91689       };
91690     }
91691   }
91692   jresult = result;
91693   return jresult;
91694 }
91695
91696
91697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91698   void * jresult ;
91699   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91700
91701   {
91702     try {
91703       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91704     } catch (std::out_of_range& e) {
91705       {
91706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91707       };
91708     } catch (std::exception& e) {
91709       {
91710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91711       };
91712     } catch (...) {
91713       {
91714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91715       };
91716     }
91717   }
91718   jresult = (void *)result;
91719   return jresult;
91720 }
91721
91722
91723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91724   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91725
91726   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91727   {
91728     try {
91729       delete arg1;
91730     } catch (std::out_of_range& e) {
91731       {
91732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91733       };
91734     } catch (std::exception& e) {
91735       {
91736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91737       };
91738     } catch (...) {
91739       {
91740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91741       };
91742     }
91743   }
91744 }
91745
91746
91747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91748   void * jresult ;
91749   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91750
91751   {
91752     try {
91753       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91754     } catch (std::out_of_range& e) {
91755       {
91756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91757       };
91758     } catch (std::exception& e) {
91759       {
91760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91761       };
91762     } catch (...) {
91763       {
91764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91765       };
91766     }
91767   }
91768   jresult = (void *)result;
91769   return jresult;
91770 }
91771
91772
91773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91774   void * jresult ;
91775   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91776   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91777
91778   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91779   {
91780     try {
91781       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91782     } catch (std::out_of_range& e) {
91783       {
91784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91785       };
91786     } catch (std::exception& e) {
91787       {
91788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91789       };
91790     } catch (...) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91793       };
91794     }
91795   }
91796   jresult = (void *)result;
91797   return jresult;
91798 }
91799
91800
91801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91802   void * jresult ;
91803   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91804   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91805
91806   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91807   if (!arg1) {
91808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91809     return 0;
91810   }
91811   {
91812     try {
91813       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91814     } catch (std::out_of_range& e) {
91815       {
91816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91817       };
91818     } catch (std::exception& e) {
91819       {
91820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91821       };
91822     } catch (...) {
91823       {
91824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91825       };
91826     }
91827   }
91828   jresult = (void *)result;
91829   return jresult;
91830 }
91831
91832
91833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91834   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91835
91836   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91837   {
91838     try {
91839       delete arg1;
91840     } catch (std::out_of_range& e) {
91841       {
91842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91843       };
91844     } catch (std::exception& e) {
91845       {
91846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91847       };
91848     } catch (...) {
91849       {
91850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91851       };
91852     }
91853   }
91854 }
91855
91856
91857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91858   void * jresult ;
91859   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91860   Dali::Toolkit::Ruler *result = 0 ;
91861
91862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91863   {
91864     try {
91865       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (...) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91877       };
91878     }
91879   }
91880   jresult = (void *)result;
91881   return jresult;
91882 }
91883
91884
91885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91886   void * jresult ;
91887   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91888   Dali::Toolkit::Ruler *result = 0 ;
91889
91890   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91891   {
91892     try {
91893       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91894     } catch (std::out_of_range& e) {
91895       {
91896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91897       };
91898     } catch (std::exception& e) {
91899       {
91900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91901       };
91902     } catch (...) {
91903       {
91904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91905       };
91906     }
91907   }
91908   jresult = (void *)result;
91909   return jresult;
91910 }
91911
91912
91913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91914   void * jresult ;
91915   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91916   Dali::Toolkit::Ruler *result = 0 ;
91917
91918   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91919   {
91920     try {
91921       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91922     } catch (std::out_of_range& e) {
91923       {
91924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91925       };
91926     } catch (std::exception& e) {
91927       {
91928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91929       };
91930     } catch (...) {
91931       {
91932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91933       };
91934     }
91935   }
91936   jresult = (void *)result;
91937   return jresult;
91938 }
91939
91940
91941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91942   void * jresult ;
91943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91944   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91945   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91946
91947   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91948   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91949   if (!arg2) {
91950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91951     return 0;
91952   }
91953   {
91954     try {
91955       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91956     } catch (std::out_of_range& e) {
91957       {
91958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91959       };
91960     } catch (std::exception& e) {
91961       {
91962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91963       };
91964     } catch (...) {
91965       {
91966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91967       };
91968     }
91969   }
91970   jresult = (void *)result;
91971   return jresult;
91972 }
91973
91974
91975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91976   void * jresult ;
91977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91978   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91980
91981   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91982   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91983   {
91984     try {
91985       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91986     } catch (std::out_of_range& e) {
91987       {
91988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91989       };
91990     } catch (std::exception& e) {
91991       {
91992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91993       };
91994     } catch (...) {
91995       {
91996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91997       };
91998     }
91999   }
92000   jresult = (void *)result;
92001   return jresult;
92002 }
92003
92004
92005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92006   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92007
92008   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92009   {
92010     try {
92011       (arg1)->Reset();
92012     } catch (std::out_of_range& e) {
92013       {
92014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92015       };
92016     } catch (std::exception& e) {
92017       {
92018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92019       };
92020     } catch (...) {
92021       {
92022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92023       };
92024     }
92025   }
92026 }
92027
92028
92029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92031   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92032
92033   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92034   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92035   {
92036     try {
92037       (arg1)->Reset(arg2);
92038     } catch (std::out_of_range& e) {
92039       {
92040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92041       };
92042     } catch (std::exception& e) {
92043       {
92044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92045       };
92046     } catch (...) {
92047       {
92048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92049       };
92050     }
92051   }
92052 }
92053
92054
92055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92056   void * jresult ;
92057   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92058   Dali::Toolkit::Ruler *result = 0 ;
92059
92060   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92061   {
92062     try {
92063       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92064     } catch (std::out_of_range& e) {
92065       {
92066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92067       };
92068     } catch (std::exception& e) {
92069       {
92070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (...) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92075       };
92076     }
92077   }
92078   jresult = (void *)result;
92079   return jresult;
92080 }
92081
92082
92083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92084   float jresult ;
92085   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92086   float arg2 ;
92087   float arg3 ;
92088   float result;
92089
92090   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92091   arg2 = (float)jarg2;
92092   arg3 = (float)jarg3;
92093   {
92094     try {
92095       result = (float)(*arg1)->Snap(arg2,arg3);
92096     } catch (std::out_of_range& e) {
92097       {
92098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92099       };
92100     } catch (std::exception& e) {
92101       {
92102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92103       };
92104     } catch (...) {
92105       {
92106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92107       };
92108     }
92109   }
92110   jresult = result;
92111   return jresult;
92112 }
92113
92114
92115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92116   float jresult ;
92117   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92118   float arg2 ;
92119   float result;
92120
92121   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92122   arg2 = (float)jarg2;
92123   {
92124     try {
92125       result = (float)(*arg1)->Snap(arg2);
92126     } catch (std::out_of_range& e) {
92127       {
92128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92129       };
92130     } catch (std::exception& e) {
92131       {
92132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92133       };
92134     } catch (...) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92137       };
92138     }
92139   }
92140   jresult = result;
92141   return jresult;
92142 }
92143
92144
92145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92146   float jresult ;
92147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92148   unsigned int arg2 ;
92149   unsigned int *arg3 = 0 ;
92150   bool arg4 ;
92151   float result;
92152
92153   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92154   arg2 = (unsigned int)jarg2;
92155   arg3 = (unsigned int *)jarg3;
92156   arg4 = jarg4 ? true : false;
92157   {
92158     try {
92159       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92160     } catch (std::out_of_range& e) {
92161       {
92162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92163       };
92164     } catch (std::exception& e) {
92165       {
92166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92167       };
92168     } catch (...) {
92169       {
92170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92171       };
92172     }
92173   }
92174   jresult = result;
92175   return jresult;
92176 }
92177
92178
92179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92180   unsigned int jresult ;
92181   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92182   float arg2 ;
92183   bool arg3 ;
92184   unsigned int result;
92185
92186   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92187   arg2 = (float)jarg2;
92188   arg3 = jarg3 ? true : false;
92189   {
92190     try {
92191       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92192     } catch (std::out_of_range& e) {
92193       {
92194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92195       };
92196     } catch (std::exception& e) {
92197       {
92198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92203       };
92204     }
92205   }
92206   jresult = result;
92207   return jresult;
92208 }
92209
92210
92211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92212   unsigned int jresult ;
92213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92214   unsigned int result;
92215
92216   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92217   {
92218     try {
92219       result = (unsigned int)(*arg1)->GetTotalPages();
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (...) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92231       };
92232     }
92233   }
92234   jresult = result;
92235   return jresult;
92236 }
92237
92238
92239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92240   int jresult ;
92241   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92242   Dali::Toolkit::Ruler::RulerType result;
92243
92244   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92245   {
92246     try {
92247       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92248     } catch (std::out_of_range& e) {
92249       {
92250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92251       };
92252     } catch (std::exception& e) {
92253       {
92254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (...) {
92257       {
92258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92259       };
92260     }
92261   }
92262   jresult = (int)result;
92263   return jresult;
92264 }
92265
92266
92267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92268   unsigned int jresult ;
92269   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92270   bool result;
92271
92272   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92273   {
92274     try {
92275       result = (bool)(*arg1)->IsEnabled();
92276     } catch (std::out_of_range& e) {
92277       {
92278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92279       };
92280     } catch (std::exception& e) {
92281       {
92282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92283       };
92284     } catch (...) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92287       };
92288     }
92289   }
92290   jresult = result;
92291   return jresult;
92292 }
92293
92294
92295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92296   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92297
92298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92299   {
92300     try {
92301       (*arg1)->Enable();
92302     } catch (std::out_of_range& e) {
92303       {
92304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92305       };
92306     } catch (std::exception& e) {
92307       {
92308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92309       };
92310     } catch (...) {
92311       {
92312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92313       };
92314     }
92315   }
92316 }
92317
92318
92319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92320   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92321
92322   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92323   {
92324     try {
92325       (*arg1)->Disable();
92326     } catch (std::out_of_range& e) {
92327       {
92328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92329       };
92330     } catch (std::exception& e) {
92331       {
92332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92333       };
92334     } catch (...) {
92335       {
92336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92337       };
92338     }
92339   }
92340 }
92341
92342
92343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92344   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92345   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92346   Dali::Toolkit::RulerDomain *argp2 ;
92347
92348   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92349   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92350   if (!argp2) {
92351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92352     return ;
92353   }
92354   arg2 = *argp2;
92355   {
92356     try {
92357       (*arg1)->SetDomain(arg2);
92358     } catch (std::out_of_range& e) {
92359       {
92360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92361       };
92362     } catch (std::exception& e) {
92363       {
92364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92369       };
92370     }
92371   }
92372 }
92373
92374
92375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92376   void * jresult ;
92377   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92378   Dali::Toolkit::RulerDomain *result = 0 ;
92379
92380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92381   {
92382     try {
92383       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92384     } catch (std::out_of_range& e) {
92385       {
92386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (std::exception& e) {
92389       {
92390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92391       };
92392     } catch (...) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92395       };
92396     }
92397   }
92398   jresult = (void *)result;
92399   return jresult;
92400 }
92401
92402
92403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92404   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92405
92406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92407   {
92408     try {
92409       (*arg1)->DisableDomain();
92410     } catch (std::out_of_range& e) {
92411       {
92412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92413       };
92414     } catch (std::exception& e) {
92415       {
92416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92417       };
92418     } catch (...) {
92419       {
92420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92421       };
92422     }
92423   }
92424 }
92425
92426
92427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92428   float jresult ;
92429   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92430   float arg2 ;
92431   float arg3 ;
92432   float arg4 ;
92433   float result;
92434
92435   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92436   arg2 = (float)jarg2;
92437   arg3 = (float)jarg3;
92438   arg4 = (float)jarg4;
92439   {
92440     try {
92441       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92442     } catch (std::out_of_range& e) {
92443       {
92444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92445       };
92446     } catch (std::exception& e) {
92447       {
92448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92449       };
92450     } catch (...) {
92451       {
92452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92453       };
92454     }
92455   }
92456   jresult = result;
92457   return jresult;
92458 }
92459
92460
92461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92462   float jresult ;
92463   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92464   float arg2 ;
92465   float arg3 ;
92466   float result;
92467
92468   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92469   arg2 = (float)jarg2;
92470   arg3 = (float)jarg3;
92471   {
92472     try {
92473       result = (float)(*arg1)->Clamp(arg2,arg3);
92474     } catch (std::out_of_range& e) {
92475       {
92476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92477       };
92478     } catch (std::exception& e) {
92479       {
92480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92481       };
92482     } catch (...) {
92483       {
92484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92485       };
92486     }
92487   }
92488   jresult = result;
92489   return jresult;
92490 }
92491
92492
92493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92494   float jresult ;
92495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92496   float arg2 ;
92497   float result;
92498
92499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92500   arg2 = (float)jarg2;
92501   {
92502     try {
92503       result = (float)(*arg1)->Clamp(arg2);
92504     } catch (std::out_of_range& e) {
92505       {
92506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92507       };
92508     } catch (std::exception& e) {
92509       {
92510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92511       };
92512     } catch (...) {
92513       {
92514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92515       };
92516     }
92517   }
92518   jresult = result;
92519   return jresult;
92520 }
92521
92522
92523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92524   float jresult ;
92525   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92526   float arg2 ;
92527   float arg3 ;
92528   float arg4 ;
92529   Dali::Toolkit::ClampState *arg5 = 0 ;
92530   float result;
92531
92532   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92533   arg2 = (float)jarg2;
92534   arg3 = (float)jarg3;
92535   arg4 = (float)jarg4;
92536   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92537   if (!arg5) {
92538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92539     return 0;
92540   }
92541   {
92542     try {
92543       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92555       };
92556     }
92557   }
92558   jresult = result;
92559   return jresult;
92560 }
92561
92562
92563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92564   float jresult ;
92565   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92566   float arg2 ;
92567   float arg3 ;
92568   float arg4 ;
92569   float arg5 ;
92570   float result;
92571
92572   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92573   arg2 = (float)jarg2;
92574   arg3 = (float)jarg3;
92575   arg4 = (float)jarg4;
92576   arg5 = (float)jarg5;
92577   {
92578     try {
92579       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92591       };
92592     }
92593   }
92594   jresult = result;
92595   return jresult;
92596 }
92597
92598
92599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92600   float jresult ;
92601   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92602   float arg2 ;
92603   float arg3 ;
92604   float arg4 ;
92605   float result;
92606
92607   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92608   arg2 = (float)jarg2;
92609   arg3 = (float)jarg3;
92610   arg4 = (float)jarg4;
92611   {
92612     try {
92613       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92614     } catch (std::out_of_range& e) {
92615       {
92616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92617       };
92618     } catch (std::exception& e) {
92619       {
92620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92621       };
92622     } catch (...) {
92623       {
92624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92625       };
92626     }
92627   }
92628   jresult = result;
92629   return jresult;
92630 }
92631
92632
92633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92634   float jresult ;
92635   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92636   float arg2 ;
92637   float arg3 ;
92638   float result;
92639
92640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92641   arg2 = (float)jarg2;
92642   arg3 = (float)jarg3;
92643   {
92644     try {
92645       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92653       };
92654     } catch (...) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92657       };
92658     }
92659   }
92660   jresult = result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92666   float jresult ;
92667   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92668   float arg2 ;
92669   float result;
92670
92671   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92672   arg2 = (float)jarg2;
92673   {
92674     try {
92675       result = (float)(*arg1)->SnapAndClamp(arg2);
92676     } catch (std::out_of_range& e) {
92677       {
92678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92679       };
92680     } catch (std::exception& e) {
92681       {
92682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92683       };
92684     } catch (...) {
92685       {
92686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92687       };
92688     }
92689   }
92690   jresult = result;
92691   return jresult;
92692 }
92693
92694
92695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92696   float jresult ;
92697   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92698   float arg2 ;
92699   float arg3 ;
92700   float arg4 ;
92701   float arg5 ;
92702   Dali::Toolkit::ClampState *arg6 = 0 ;
92703   float result;
92704
92705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92706   arg2 = (float)jarg2;
92707   arg3 = (float)jarg3;
92708   arg4 = (float)jarg4;
92709   arg5 = (float)jarg5;
92710   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92711   if (!arg6) {
92712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92713     return 0;
92714   }
92715   {
92716     try {
92717       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92718     } catch (std::out_of_range& e) {
92719       {
92720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92721       };
92722     } catch (std::exception& e) {
92723       {
92724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92725       };
92726     } catch (...) {
92727       {
92728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92729       };
92730     }
92731   }
92732   jresult = result;
92733   return jresult;
92734 }
92735
92736
92737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92738   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92739
92740   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92741   {
92742     try {
92743       (*arg1)->Reference();
92744     } catch (std::out_of_range& e) {
92745       {
92746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92747       };
92748     } catch (std::exception& e) {
92749       {
92750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92751       };
92752     } catch (...) {
92753       {
92754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92755       };
92756     }
92757   }
92758 }
92759
92760
92761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92762   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92763
92764   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92765   {
92766     try {
92767       (*arg1)->Unreference();
92768     } catch (std::out_of_range& e) {
92769       {
92770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92771       };
92772     } catch (std::exception& e) {
92773       {
92774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92775       };
92776     } catch (...) {
92777       {
92778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92779       };
92780     }
92781   }
92782 }
92783
92784
92785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92786   int jresult ;
92787   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92788   int result;
92789
92790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92791   {
92792     try {
92793       result = (int)(*arg1)->ReferenceCount();
92794     } catch (std::out_of_range& e) {
92795       {
92796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92797       };
92798     } catch (std::exception& e) {
92799       {
92800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92801       };
92802     } catch (...) {
92803       {
92804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92805       };
92806     }
92807   }
92808   jresult = result;
92809   return jresult;
92810 }
92811
92812
92813 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92814     return (Dali::RefObject *)jarg1;
92815 }
92816
92817 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92818     return (Dali::SignalObserver *)jarg1;
92819 }
92820
92821 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92822     return (Dali::ConnectionTrackerInterface *)jarg1;
92823 }
92824
92825 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92826     return (Dali::BaseHandle *)jarg1;
92827 }
92828
92829 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92830     return (Dali::BaseHandle *)jarg1;
92831 }
92832
92833 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92834     return (Dali::BaseHandle *)jarg1;
92835 }
92836
92837 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92838     return (Dali::BaseHandle *)jarg1;
92839 }
92840
92841 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92842     return (Dali::BaseHandle *)jarg1;
92843 }
92844
92845 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92846     return (Dali::BaseHandle *)jarg1;
92847 }
92848
92849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92850     return (Dali::BaseHandle *)jarg1;
92851 }
92852
92853 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92854     return (Dali::BaseHandle *)jarg1;
92855 }
92856
92857 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92858     return (Dali::BaseHandle *)jarg1;
92859 }
92860
92861 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92862     return (Dali::BaseHandle *)jarg1;
92863 }
92864
92865 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92866     return (Dali::BaseHandle *)jarg1;
92867 }
92868
92869 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92870     return (Dali::BaseHandle *)jarg1;
92871 }
92872
92873 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92874     return (Dali::BaseHandle *)jarg1;
92875 }
92876
92877 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92878     return (Dali::Handle *)jarg1;
92879 }
92880
92881 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92882     return (Dali::Handle *)jarg1;
92883 }
92884
92885 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92886     return (Dali::BaseHandle *)jarg1;
92887 }
92888
92889 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92890     return (Dali::BaseHandle *)jarg1;
92891 }
92892
92893 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92894     return (Dali::Handle *)jarg1;
92895 }
92896
92897 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92898     return (Dali::BaseHandle *)jarg1;
92899 }
92900
92901 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92902     return (Dali::Handle *)jarg1;
92903 }
92904
92905 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92906     return (Dali::GestureDetector *)jarg1;
92907 }
92908
92909 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92910     return (Dali::Gesture *)jarg1;
92911 }
92912
92913 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92914     return (Dali::Handle *)jarg1;
92915 }
92916
92917 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92918     return (Dali::Actor *)jarg1;
92919 }
92920
92921 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92922     return (Dali::BaseHandle *)jarg1;
92923 }
92924
92925 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92926     return (Dali::RefObject *)jarg1;
92927 }
92928
92929 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92930     return (Dali::Actor *)jarg1;
92931 }
92932
92933 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92934     return (Dali::GestureDetector *)jarg1;
92935 }
92936
92937 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92938     return (Dali::Gesture *)jarg1;
92939 }
92940
92941 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92942     return (Dali::GestureDetector *)jarg1;
92943 }
92944
92945 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92946     return (Dali::Gesture *)jarg1;
92947 }
92948
92949 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92950     return (Dali::GestureDetector *)jarg1;
92951 }
92952
92953 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92954     return (Dali::Gesture *)jarg1;
92955 }
92956
92957 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92958     return (Dali::BaseHandle *)jarg1;
92959 }
92960
92961 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92962     return (Dali::Handle *)jarg1;
92963 }
92964
92965 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92966     return (Dali::BaseHandle *)jarg1;
92967 }
92968
92969 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92970     return (Dali::Handle *)jarg1;
92971 }
92972
92973 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92974     return (Dali::Handle *)jarg1;
92975 }
92976
92977 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92978     return (Dali::Image *)jarg1;
92979 }
92980
92981 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92982     return (Dali::Image *)jarg1;
92983 }
92984
92985 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92986     return (Dali::Image *)jarg1;
92987 }
92988
92989 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92990     return (Dali::RefObject *)jarg1;
92991 }
92992
92993 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92994     return (Dali::Image *)jarg1;
92995 }
92996
92997 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92998     return (Dali::Image *)jarg1;
92999 }
93000
93001 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93002     return (Dali::ResourceImage *)jarg1;
93003 }
93004
93005 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93006     return (Dali::Actor *)jarg1;
93007 }
93008
93009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93010     return (Dali::BaseHandle *)jarg1;
93011 }
93012
93013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93014     return (Dali::BaseHandle *)jarg1;
93015 }
93016
93017 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93018     return (Dali::BaseHandle *)jarg1;
93019 }
93020
93021 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93022     return (Dali::BaseHandle *)jarg1;
93023 }
93024
93025 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93026     return (Dali::BaseHandle *)jarg1;
93027 }
93028
93029 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93030     return (Dali::BaseHandle *)jarg1;
93031 }
93032
93033 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93034     return (Dali::CustomActorImpl *)jarg1;
93035 }
93036
93037 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93038     return (Dali::CustomActor *)jarg1;
93039 }
93040
93041 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93042     return (Dali::BaseHandle *)jarg1;
93043 }
93044
93045 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93046     return (Dali::Toolkit::Control *)jarg1;
93047 }
93048
93049 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93050     return (Dali::Toolkit::Control *)jarg1;
93051 }
93052
93053 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93054     return (Dali::Toolkit::Button *)jarg1;
93055 }
93056
93057 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93058     return (Dali::Toolkit::Button *)jarg1;
93059 }
93060
93061 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93062     return (Dali::Toolkit::Button *)jarg1;
93063 }
93064
93065 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93066     return (Dali::Toolkit::Control *)jarg1;
93067 }
93068
93069 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93070     return (Dali::Toolkit::Control *)jarg1;
93071 }
93072
93073 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93074     return (Dali::Toolkit::Control *)jarg1;
93075 }
93076
93077 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93078     return (Dali::Toolkit::Control *)jarg1;
93079 }
93080
93081 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93082     return (Dali::Toolkit::Control *)jarg1;
93083 }
93084
93085 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93086     return (Dali::RefObject *)jarg1;
93087 }
93088
93089 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93090     return (Dali::Toolkit::Scrollable *)jarg1;
93091 }
93092
93093 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93094     return (Dali::BaseHandle *)jarg1;
93095 }
93096
93097 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93098     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93099 }
93100
93101 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93102     return (Dali::RefObject *)jarg1;
93103 }
93104
93105 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93106     return (Dali::Toolkit::Ruler *)jarg1;
93107 }
93108
93109 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93110     return (Dali::Toolkit::Ruler *)jarg1;
93111 }
93112
93113 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93114     return (Dali::Toolkit::Scrollable *)jarg1;
93115 }
93116
93117 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93118     return (Dali::Toolkit::Control *)jarg1;
93119 }
93120
93121 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93122     return (Dali::Toolkit::Control *)jarg1;
93123 }
93124
93125 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93126     return (Dali::Toolkit::Control *)jarg1;
93127 }
93128
93129 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93130     return (Dali::Toolkit::Control *)jarg1;
93131 }
93132
93133 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93134     return (Dali::BaseHandle *)jarg1;
93135 }
93136
93137 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93138     return (Dali::BaseHandle *)jarg1;
93139 }
93140
93141 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93142     return (Dali::Toolkit::Control *)jarg1;
93143 }
93144
93145 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93146     return (Dali::Toolkit::Control *)jarg1;
93147 }
93148
93149 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93150     return (Dali::Toolkit::Control *)jarg1;
93151 }
93152
93153 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93154     return (Dali::Toolkit::Control *)jarg1;
93155 }
93156
93157 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93158     return (Dali::Toolkit::Control *)jarg1;
93159 }
93160
93161 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93162     return (Dali::Toolkit::Control *)jarg1;
93163 }
93164
93165 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93166     return (Dali::Toolkit::PageTurnView *)jarg1;
93167 }
93168
93169 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93170     return (Dali::Toolkit::PageTurnView *)jarg1;
93171 }
93172
93173 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93174     return (Dali::Toolkit::Button *)jarg1;
93175 }
93176
93177 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93178     return (Dali::BaseHandle *)jarg1;
93179 }
93180
93181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93182     return (Dali::BaseHandle *)jarg1;
93183 }
93184
93185 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93186     return (Dali::BaseHandle *)jarg1;
93187 }
93188
93189 #ifdef __cplusplus
93190 }
93191 #endif
93192